From 5e98c280a8058e810687e073590836218d68ba38 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:51:38 -0400 Subject: [PATCH 01/11] feat(settings): add MerkleDistributor address and tree host settings --- charts/identity-api/values-prod.yaml | 4 ++++ charts/identity-api/values.yaml | 4 ++++ internal/config/settings.go | 4 ++++ settings.sample.yaml | 5 ++++- 4 files changed, 16 insertions(+), 1 deletion(-) diff --git a/charts/identity-api/values-prod.yaml b/charts/identity-api/values-prod.yaml index 4fe9b4f2..d7364be3 100644 --- a/charts/identity-api/values-prod.yaml +++ b/charts/identity-api/values-prod.yaml @@ -26,6 +26,10 @@ env: DEV_LICENSE_ADDR: '0x9A9D2E717bB005B240094ba761Ff074d392C7C85' STAKING_ADDR: '0xB4538A8D6AFab2849Ef78D08D49Dc1cc5AC2eD83' FETCH_API_GRPC_ADDR: fetch-api-prod:8086 + # TODO: replace placeholder with deployed MerkleDistributor address. + MERKLE_DISTRIBUTOR_ADDR: '0x0000000000000000000000000000000000000000' + # Comma-separated list of hosts from which RootSet Merkle tree files may be fetched. + MERKLE_TREE_ALLOWED_HOST: merkle.dimo.zone ingress: enabled: true className: nginx diff --git a/charts/identity-api/values.yaml b/charts/identity-api/values.yaml index 44915a85..fbca7480 100644 --- a/charts/identity-api/values.yaml +++ b/charts/identity-api/values.yaml @@ -53,6 +53,10 @@ env: STORAGE_NODE_ADDR: '0xf76eEBa34B19aDb7eEa9E4Eea05243D7E5a30123' TEMPLATE_ADDR: '0x0000000000000000000000000000000000000000' FETCH_API_GRPC_ADDR: fetch-api-dev:8086 + # TODO: replace placeholder with deployed MerkleDistributor address. + MERKLE_DISTRIBUTOR_ADDR: '0x0000000000000000000000000000000000000000' + # Comma-separated list of hosts from which RootSet Merkle tree files may be fetched. + MERKLE_TREE_ALLOWED_HOST: merkle.dev.dimo.zone service: type: ClusterIP ports: diff --git a/internal/config/settings.go b/internal/config/settings.go index 408d47c5..b0e03e5f 100644 --- a/internal/config/settings.go +++ b/internal/config/settings.go @@ -30,4 +30,8 @@ type Settings struct { StorageNodeAddr string `yaml:"STORAGE_NODE_ADDR"` TemplateAddr string `yaml:"TEMPLATE_ADDR"` FetchAPIGRPCAddr string `yaml:"FETCH_API_GRPC_ADDR"` + MerkleDistributorAddr string `yaml:"MERKLE_DISTRIBUTOR_ADDR"` + // MerkleTreeAllowedHost is a comma-separated list of hosts from which the + // consumer is willing to fetch Merkle tree files referenced by RootSet events. + MerkleTreeAllowedHost string `yaml:"MERKLE_TREE_ALLOWED_HOST"` } diff --git a/settings.sample.yaml b/settings.sample.yaml index 80bc3cae..c2537065 100644 --- a/settings.sample.yaml +++ b/settings.sample.yaml @@ -19,4 +19,7 @@ REWARDS_CONTRACT_ADDRESS: "0x375885164266d48C48abbbb439Be98864Ae62bBE" TEMPLATE_ADDR: "0x0000000000000000000000000000000000000000" BASE_IMAGE_URL: "https://devices-api.dev.dimo.zone/v1/" TABLELAND_API_GATEWAY: "https://testnets.tableland.network/" -ETHEREUM_RPC_URL: "http://127.0.0.1:8545" \ No newline at end of file +ETHEREUM_RPC_URL: "http://127.0.0.1:8545"# TODO: replace placeholder with deployed MerkleDistributor address. +MERKLE_DISTRIBUTOR_ADDR: "0x0000000000000000000000000000000000000000" +# Comma-separated list of hosts from which RootSet Merkle tree files may be fetched, e.g. merkle.dimo.zone. +MERKLE_TREE_ALLOWED_HOST: "" From 27302246ee19fffd6f2c91281e63a00858715b22 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:51:38 -0400 Subject: [PATCH 02/11] feat(db): add merkle_pools, merkle_roots, and merkle_claims tables --- migrations/00049_create_merkle_tables.sql | 47 + models/boil_table_names.go | 6 + models/merkle_claims.go | 1007 +++++++++++++++++ models/merkle_pools.go | 1197 +++++++++++++++++++++ models/merkle_roots.go | 1176 ++++++++++++++++++++ models/rewards.go | 21 - 6 files changed, 3433 insertions(+), 21 deletions(-) create mode 100644 migrations/00049_create_merkle_tables.sql create mode 100644 models/merkle_claims.go create mode 100644 models/merkle_pools.go create mode 100644 models/merkle_roots.go diff --git a/migrations/00049_create_merkle_tables.sql b/migrations/00049_create_merkle_tables.sql new file mode 100644 index 00000000..51ef9786 --- /dev/null +++ b/migrations/00049_create_merkle_tables.sql @@ -0,0 +1,47 @@ +-- +goose Up +-- +goose StatementBegin +CREATE TABLE merkle_pools ( + pool_id int CONSTRAINT merkle_pools_pkey PRIMARY KEY, + token bytea NOT NULL CONSTRAINT merkle_pools_token_check CHECK (length(token) = 20), + admin bytea NOT NULL CONSTRAINT merkle_pools_admin_check CHECK (length(admin) = 20), + weekly_limit numeric(38, 0), + balance numeric(38, 0) NOT NULL DEFAULT 0, + created_at timestamptz NOT NULL +); + +CREATE TABLE merkle_roots ( + pool_id int NOT NULL CONSTRAINT merkle_roots_pool_id_fkey REFERENCES merkle_pools (pool_id), + epoch int NOT NULL, + root bytea NOT NULL CONSTRAINT merkle_roots_root_check CHECK (length(root) = 32), + allocation numeric(38, 0) NOT NULL, + total_claimed numeric(38, 0) NOT NULL DEFAULT 0, + claim_count int NOT NULL DEFAULT 0, + recipient_count int NOT NULL DEFAULT 0, + proofs_uri text NOT NULL, + set_at timestamptz NOT NULL, + CONSTRAINT merkle_roots_pkey PRIMARY KEY (pool_id, epoch) +); + +CREATE TABLE merkle_claims ( + pool_id int NOT NULL, + epoch int NOT NULL, + account bytea NOT NULL CONSTRAINT merkle_claims_account_check CHECK (length(account) = 20), + amount numeric(38, 0) NOT NULL, + proof jsonb NOT NULL, + claimed_at timestamptz, + claim_tx bytea CONSTRAINT merkle_claims_claim_tx_check CHECK (claim_tx IS NULL OR length(claim_tx) = 32), + CONSTRAINT merkle_claims_pkey PRIMARY KEY (pool_id, epoch, account), + CONSTRAINT merkle_claims_pool_id_epoch_fkey FOREIGN KEY (pool_id, epoch) REFERENCES merkle_roots (pool_id, epoch) +); + +CREATE INDEX merkle_claims_account_idx ON merkle_claims (account); +-- +goose StatementEnd + +-- +goose Down +-- +goose StatementBegin +DROP TABLE merkle_claims; + +DROP TABLE merkle_roots; + +DROP TABLE merkle_pools; +-- +goose StatementEnd diff --git a/models/boil_table_names.go b/models/boil_table_names.go index 58e97e8e..c83fa267 100644 --- a/models/boil_table_names.go +++ b/models/boil_table_names.go @@ -10,6 +10,9 @@ var TableNames = struct { DCNS string DeveloperLicenses string Manufacturers string + MerkleClaims string + MerklePools string + MerkleRoots string Privileges string RedirectUris string Rewards string @@ -27,6 +30,9 @@ var TableNames = struct { DCNS: "dcns", DeveloperLicenses: "developer_licenses", Manufacturers: "manufacturers", + MerkleClaims: "merkle_claims", + MerklePools: "merkle_pools", + MerkleRoots: "merkle_roots", Privileges: "privileges", RedirectUris: "redirect_uris", Rewards: "rewards", diff --git a/models/merkle_claims.go b/models/merkle_claims.go new file mode 100644 index 00000000..b66428a2 --- /dev/null +++ b/models/merkle_claims.go @@ -0,0 +1,1007 @@ +// Code generated by SQLBoiler 4.19.5 (https://github.com/aarondl/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package models + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + "time" + + "github.com/aarondl/null/v8" + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/aarondl/sqlboiler/v4/queries" + "github.com/aarondl/sqlboiler/v4/queries/qm" + "github.com/aarondl/sqlboiler/v4/queries/qmhelper" + "github.com/aarondl/sqlboiler/v4/types" + "github.com/aarondl/strmangle" + "github.com/friendsofgo/errors" +) + +// MerkleClaim is an object representing the database table. +type MerkleClaim struct { + PoolID int `boil:"pool_id" json:"pool_id" toml:"pool_id" yaml:"pool_id"` + Epoch int `boil:"epoch" json:"epoch" toml:"epoch" yaml:"epoch"` + Account []byte `boil:"account" json:"account" toml:"account" yaml:"account"` + Amount types.Decimal `boil:"amount" json:"amount" toml:"amount" yaml:"amount"` + Proof types.JSON `boil:"proof" json:"proof" toml:"proof" yaml:"proof"` + ClaimedAt null.Time `boil:"claimed_at" json:"claimed_at,omitempty" toml:"claimed_at" yaml:"claimed_at,omitempty"` + ClaimTX null.Bytes `boil:"claim_tx" json:"claim_tx,omitempty" toml:"claim_tx" yaml:"claim_tx,omitempty"` + + R *merkleClaimR `boil:"-" json:"-" toml:"-" yaml:"-"` + L merkleClaimL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var MerkleClaimColumns = struct { + PoolID string + Epoch string + Account string + Amount string + Proof string + ClaimedAt string + ClaimTX string +}{ + PoolID: "pool_id", + Epoch: "epoch", + Account: "account", + Amount: "amount", + Proof: "proof", + ClaimedAt: "claimed_at", + ClaimTX: "claim_tx", +} + +var MerkleClaimTableColumns = struct { + PoolID string + Epoch string + Account string + Amount string + Proof string + ClaimedAt string + ClaimTX string +}{ + PoolID: "merkle_claims.pool_id", + Epoch: "merkle_claims.epoch", + Account: "merkle_claims.account", + Amount: "merkle_claims.amount", + Proof: "merkle_claims.proof", + ClaimedAt: "merkle_claims.claimed_at", + ClaimTX: "merkle_claims.claim_tx", +} + +// Generated where + +type whereHelpertypes_Decimal struct{ field string } + +func (w whereHelpertypes_Decimal) EQ(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.EQ, x) +} +func (w whereHelpertypes_Decimal) NEQ(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.NEQ, x) +} +func (w whereHelpertypes_Decimal) LT(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LT, x) +} +func (w whereHelpertypes_Decimal) LTE(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LTE, x) +} +func (w whereHelpertypes_Decimal) GT(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GT, x) +} +func (w whereHelpertypes_Decimal) GTE(x types.Decimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GTE, x) +} + +type whereHelpertypes_JSON struct{ field string } + +func (w whereHelpertypes_JSON) EQ(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.EQ, x) +} +func (w whereHelpertypes_JSON) NEQ(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.NEQ, x) +} +func (w whereHelpertypes_JSON) LT(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LT, x) +} +func (w whereHelpertypes_JSON) LTE(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LTE, x) +} +func (w whereHelpertypes_JSON) GT(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GT, x) +} +func (w whereHelpertypes_JSON) GTE(x types.JSON) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GTE, x) +} + +var MerkleClaimWhere = struct { + PoolID whereHelperint + Epoch whereHelperint + Account whereHelper__byte + Amount whereHelpertypes_Decimal + Proof whereHelpertypes_JSON + ClaimedAt whereHelpernull_Time + ClaimTX whereHelpernull_Bytes +}{ + PoolID: whereHelperint{field: "\"identity_api\".\"merkle_claims\".\"pool_id\""}, + Epoch: whereHelperint{field: "\"identity_api\".\"merkle_claims\".\"epoch\""}, + Account: whereHelper__byte{field: "\"identity_api\".\"merkle_claims\".\"account\""}, + Amount: whereHelpertypes_Decimal{field: "\"identity_api\".\"merkle_claims\".\"amount\""}, + Proof: whereHelpertypes_JSON{field: "\"identity_api\".\"merkle_claims\".\"proof\""}, + ClaimedAt: whereHelpernull_Time{field: "\"identity_api\".\"merkle_claims\".\"claimed_at\""}, + ClaimTX: whereHelpernull_Bytes{field: "\"identity_api\".\"merkle_claims\".\"claim_tx\""}, +} + +// MerkleClaimRels is where relationship names are stored. +var MerkleClaimRels = struct { +}{} + +// merkleClaimR is where relationships are stored. +type merkleClaimR struct { +} + +// NewStruct creates a new relationship struct +func (*merkleClaimR) NewStruct() *merkleClaimR { + return &merkleClaimR{} +} + +// merkleClaimL is where Load methods for each relationship are stored. +type merkleClaimL struct{} + +var ( + merkleClaimAllColumns = []string{"pool_id", "epoch", "account", "amount", "proof", "claimed_at", "claim_tx"} + merkleClaimColumnsWithoutDefault = []string{"pool_id", "epoch", "account", "amount", "proof"} + merkleClaimColumnsWithDefault = []string{"claimed_at", "claim_tx"} + merkleClaimPrimaryKeyColumns = []string{"pool_id", "epoch", "account"} + merkleClaimGeneratedColumns = []string{} +) + +type ( + // MerkleClaimSlice is an alias for a slice of pointers to MerkleClaim. + // This should almost always be used instead of []MerkleClaim. + MerkleClaimSlice []*MerkleClaim + // MerkleClaimHook is the signature for custom MerkleClaim hook methods + MerkleClaimHook func(context.Context, boil.ContextExecutor, *MerkleClaim) error + + merkleClaimQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + merkleClaimType = reflect.TypeOf(&MerkleClaim{}) + merkleClaimMapping = queries.MakeStructMapping(merkleClaimType) + merkleClaimPrimaryKeyMapping, _ = queries.BindMapping(merkleClaimType, merkleClaimMapping, merkleClaimPrimaryKeyColumns) + merkleClaimInsertCacheMut sync.RWMutex + merkleClaimInsertCache = make(map[string]insertCache) + merkleClaimUpdateCacheMut sync.RWMutex + merkleClaimUpdateCache = make(map[string]updateCache) + merkleClaimUpsertCacheMut sync.RWMutex + merkleClaimUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var merkleClaimAfterSelectMu sync.Mutex +var merkleClaimAfterSelectHooks []MerkleClaimHook + +var merkleClaimBeforeInsertMu sync.Mutex +var merkleClaimBeforeInsertHooks []MerkleClaimHook +var merkleClaimAfterInsertMu sync.Mutex +var merkleClaimAfterInsertHooks []MerkleClaimHook + +var merkleClaimBeforeUpdateMu sync.Mutex +var merkleClaimBeforeUpdateHooks []MerkleClaimHook +var merkleClaimAfterUpdateMu sync.Mutex +var merkleClaimAfterUpdateHooks []MerkleClaimHook + +var merkleClaimBeforeDeleteMu sync.Mutex +var merkleClaimBeforeDeleteHooks []MerkleClaimHook +var merkleClaimAfterDeleteMu sync.Mutex +var merkleClaimAfterDeleteHooks []MerkleClaimHook + +var merkleClaimBeforeUpsertMu sync.Mutex +var merkleClaimBeforeUpsertHooks []MerkleClaimHook +var merkleClaimAfterUpsertMu sync.Mutex +var merkleClaimAfterUpsertHooks []MerkleClaimHook + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *MerkleClaim) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *MerkleClaim) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *MerkleClaim) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *MerkleClaim) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *MerkleClaim) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *MerkleClaim) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *MerkleClaim) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *MerkleClaim) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *MerkleClaim) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleClaimAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddMerkleClaimHook registers your hook function for all future operations. +func AddMerkleClaimHook(hookPoint boil.HookPoint, merkleClaimHook MerkleClaimHook) { + switch hookPoint { + case boil.AfterSelectHook: + merkleClaimAfterSelectMu.Lock() + merkleClaimAfterSelectHooks = append(merkleClaimAfterSelectHooks, merkleClaimHook) + merkleClaimAfterSelectMu.Unlock() + case boil.BeforeInsertHook: + merkleClaimBeforeInsertMu.Lock() + merkleClaimBeforeInsertHooks = append(merkleClaimBeforeInsertHooks, merkleClaimHook) + merkleClaimBeforeInsertMu.Unlock() + case boil.AfterInsertHook: + merkleClaimAfterInsertMu.Lock() + merkleClaimAfterInsertHooks = append(merkleClaimAfterInsertHooks, merkleClaimHook) + merkleClaimAfterInsertMu.Unlock() + case boil.BeforeUpdateHook: + merkleClaimBeforeUpdateMu.Lock() + merkleClaimBeforeUpdateHooks = append(merkleClaimBeforeUpdateHooks, merkleClaimHook) + merkleClaimBeforeUpdateMu.Unlock() + case boil.AfterUpdateHook: + merkleClaimAfterUpdateMu.Lock() + merkleClaimAfterUpdateHooks = append(merkleClaimAfterUpdateHooks, merkleClaimHook) + merkleClaimAfterUpdateMu.Unlock() + case boil.BeforeDeleteHook: + merkleClaimBeforeDeleteMu.Lock() + merkleClaimBeforeDeleteHooks = append(merkleClaimBeforeDeleteHooks, merkleClaimHook) + merkleClaimBeforeDeleteMu.Unlock() + case boil.AfterDeleteHook: + merkleClaimAfterDeleteMu.Lock() + merkleClaimAfterDeleteHooks = append(merkleClaimAfterDeleteHooks, merkleClaimHook) + merkleClaimAfterDeleteMu.Unlock() + case boil.BeforeUpsertHook: + merkleClaimBeforeUpsertMu.Lock() + merkleClaimBeforeUpsertHooks = append(merkleClaimBeforeUpsertHooks, merkleClaimHook) + merkleClaimBeforeUpsertMu.Unlock() + case boil.AfterUpsertHook: + merkleClaimAfterUpsertMu.Lock() + merkleClaimAfterUpsertHooks = append(merkleClaimAfterUpsertHooks, merkleClaimHook) + merkleClaimAfterUpsertMu.Unlock() + } +} + +// One returns a single merkleClaim record from the query. +func (q merkleClaimQuery) One(ctx context.Context, exec boil.ContextExecutor) (*MerkleClaim, error) { + o := &MerkleClaim{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: failed to execute a one query for merkle_claims") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all MerkleClaim records from the query. +func (q merkleClaimQuery) All(ctx context.Context, exec boil.ContextExecutor) (MerkleClaimSlice, error) { + var o []*MerkleClaim + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "models: failed to assign all query results to MerkleClaim slice") + } + + if len(merkleClaimAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all MerkleClaim records in the query. +func (q merkleClaimQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "models: failed to count merkle_claims rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q merkleClaimQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "models: failed to check if merkle_claims exists") + } + + return count > 0, nil +} + +// MerkleClaims retrieves all the records using an executor. +func MerkleClaims(mods ...qm.QueryMod) merkleClaimQuery { + mods = append(mods, qm.From("\"identity_api\".\"merkle_claims\"")) + q := NewQuery(mods...) + if len(queries.GetSelect(q)) == 0 { + queries.SetSelect(q, []string{"\"identity_api\".\"merkle_claims\".*"}) + } + + return merkleClaimQuery{q} +} + +// FindMerkleClaim retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindMerkleClaim(ctx context.Context, exec boil.ContextExecutor, poolID int, epoch int, account []byte, selectCols ...string) (*MerkleClaim, error) { + merkleClaimObj := &MerkleClaim{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"identity_api\".\"merkle_claims\" where \"pool_id\"=$1 AND \"epoch\"=$2 AND \"account\"=$3", sel, + ) + + q := queries.Raw(query, poolID, epoch, account) + + err := q.Bind(ctx, exec, merkleClaimObj) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: unable to select from merkle_claims") + } + + if err = merkleClaimObj.doAfterSelectHooks(ctx, exec); err != nil { + return merkleClaimObj, err + } + + return merkleClaimObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *MerkleClaim) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("models: no merkle_claims provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merkleClaimColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + merkleClaimInsertCacheMut.RLock() + cache, cached := merkleClaimInsertCache[key] + merkleClaimInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + merkleClaimAllColumns, + merkleClaimColumnsWithDefault, + merkleClaimColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(merkleClaimType, merkleClaimMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(merkleClaimType, merkleClaimMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"identity_api\".\"merkle_claims\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"identity_api\".\"merkle_claims\" %sDEFAULT VALUES%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + + if err != nil { + return errors.Wrap(err, "models: unable to insert into merkle_claims") + } + + if !cached { + merkleClaimInsertCacheMut.Lock() + merkleClaimInsertCache[key] = cache + merkleClaimInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the MerkleClaim. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *MerkleClaim) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + merkleClaimUpdateCacheMut.RLock() + cache, cached := merkleClaimUpdateCache[key] + merkleClaimUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + merkleClaimAllColumns, + merkleClaimPrimaryKeyColumns, + ) + + if !columns.IsWhitelist() { + wl = strmangle.SetComplement(wl, []string{"created_at"}) + } + if len(wl) == 0 { + return 0, errors.New("models: unable to update merkle_claims, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"identity_api\".\"merkle_claims\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, wl), + strmangle.WhereClause("\"", "\"", len(wl)+1, merkleClaimPrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(merkleClaimType, merkleClaimMapping, append(wl, merkleClaimPrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, values) + } + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update merkle_claims row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by update for merkle_claims") + } + + if !cached { + merkleClaimUpdateCacheMut.Lock() + merkleClaimUpdateCache[key] = cache + merkleClaimUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q merkleClaimQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all for merkle_claims") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected for merkle_claims") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o MerkleClaimSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("models: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleClaimPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"identity_api\".\"merkle_claims\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, merkleClaimPrimaryKeyColumns, len(o))) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all in merkleClaim slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all merkleClaim") + } + return rowsAff, nil +} + +// Upsert attempts an insert using an executor, and does an update or ignore on conflict. +// See boil.Columns documentation for how to properly use updateColumns and insertColumns. +func (o *MerkleClaim) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns, opts ...UpsertOptionFunc) error { + if o == nil { + return errors.New("models: no merkle_claims provided for upsert") + } + + if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merkleClaimColumnsWithDefault, o) + + // Build cache key in-line uglily - mysql vs psql problems + buf := strmangle.GetBuffer() + if updateOnConflict { + buf.WriteByte('t') + } else { + buf.WriteByte('f') + } + buf.WriteByte('.') + for _, c := range conflictColumns { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(updateColumns.Kind)) + for _, c := range updateColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(insertColumns.Kind)) + for _, c := range insertColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + for _, c := range nzDefaults { + buf.WriteString(c) + } + key := buf.String() + strmangle.PutBuffer(buf) + + merkleClaimUpsertCacheMut.RLock() + cache, cached := merkleClaimUpsertCache[key] + merkleClaimUpsertCacheMut.RUnlock() + + var err error + + if !cached { + insert, _ := insertColumns.InsertColumnSet( + merkleClaimAllColumns, + merkleClaimColumnsWithDefault, + merkleClaimColumnsWithoutDefault, + nzDefaults, + ) + + update := updateColumns.UpdateColumnSet( + merkleClaimAllColumns, + merkleClaimPrimaryKeyColumns, + ) + + if updateOnConflict && len(update) == 0 { + return errors.New("models: unable to upsert merkle_claims, could not build update column list") + } + + ret := strmangle.SetComplement(merkleClaimAllColumns, strmangle.SetIntersect(insert, update)) + + conflict := conflictColumns + if len(conflict) == 0 && updateOnConflict && len(update) != 0 { + if len(merkleClaimPrimaryKeyColumns) == 0 { + return errors.New("models: unable to upsert merkle_claims, could not build conflict column list") + } + + conflict = make([]string, len(merkleClaimPrimaryKeyColumns)) + copy(conflict, merkleClaimPrimaryKeyColumns) + } + cache.query = buildUpsertQueryPostgres(dialect, "\"identity_api\".\"merkle_claims\"", updateOnConflict, ret, update, conflict, insert, opts...) + + cache.valueMapping, err = queries.BindMapping(merkleClaimType, merkleClaimMapping, insert) + if err != nil { + return err + } + if len(ret) != 0 { + cache.retMapping, err = queries.BindMapping(merkleClaimType, merkleClaimMapping, ret) + if err != nil { + return err + } + } + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + var returns []interface{} + if len(cache.retMapping) != 0 { + returns = queries.PtrsFromMapping(value, cache.retMapping) + } + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) + if errors.Is(err, sql.ErrNoRows) { + err = nil // Postgres doesn't return anything when there's no update + } + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + if err != nil { + return errors.Wrap(err, "models: unable to upsert merkle_claims") + } + + if !cached { + merkleClaimUpsertCacheMut.Lock() + merkleClaimUpsertCache[key] = cache + merkleClaimUpsertCacheMut.Unlock() + } + + return o.doAfterUpsertHooks(ctx, exec) +} + +// Delete deletes a single MerkleClaim record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *MerkleClaim) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("models: no MerkleClaim provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), merkleClaimPrimaryKeyMapping) + sql := "DELETE FROM \"identity_api\".\"merkle_claims\" WHERE \"pool_id\"=$1 AND \"epoch\"=$2 AND \"account\"=$3" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete from merkle_claims") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by delete for merkle_claims") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q merkleClaimQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("models: no merkleClaimQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merkle_claims") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_claims") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o MerkleClaimSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(merkleClaimBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleClaimPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"identity_api\".\"merkle_claims\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merkleClaimPrimaryKeyColumns, len(o)) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merkleClaim slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_claims") + } + + if len(merkleClaimAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *MerkleClaim) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindMerkleClaim(ctx, exec, o.PoolID, o.Epoch, o.Account) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *MerkleClaimSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := MerkleClaimSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleClaimPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"identity_api\".\"merkle_claims\".* FROM \"identity_api\".\"merkle_claims\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merkleClaimPrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "models: unable to reload all in MerkleClaimSlice") + } + + *o = slice + + return nil +} + +// MerkleClaimExists checks if the MerkleClaim row exists. +func MerkleClaimExists(ctx context.Context, exec boil.ContextExecutor, poolID int, epoch int, account []byte) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"identity_api\".\"merkle_claims\" where \"pool_id\"=$1 AND \"epoch\"=$2 AND \"account\"=$3 limit 1)" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, poolID, epoch, account) + } + row := exec.QueryRowContext(ctx, sql, poolID, epoch, account) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "models: unable to check if merkle_claims exists") + } + + return exists, nil +} + +// Exists checks if the MerkleClaim row exists. +func (o *MerkleClaim) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + return MerkleClaimExists(ctx, exec, o.PoolID, o.Epoch, o.Account) +} diff --git a/models/merkle_pools.go b/models/merkle_pools.go new file mode 100644 index 00000000..307826c2 --- /dev/null +++ b/models/merkle_pools.go @@ -0,0 +1,1197 @@ +// Code generated by SQLBoiler 4.19.5 (https://github.com/aarondl/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package models + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + "time" + + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/aarondl/sqlboiler/v4/queries" + "github.com/aarondl/sqlboiler/v4/queries/qm" + "github.com/aarondl/sqlboiler/v4/queries/qmhelper" + "github.com/aarondl/sqlboiler/v4/types" + "github.com/aarondl/strmangle" + "github.com/friendsofgo/errors" +) + +// MerklePool is an object representing the database table. +type MerklePool struct { + PoolID int `boil:"pool_id" json:"pool_id" toml:"pool_id" yaml:"pool_id"` + Token []byte `boil:"token" json:"token" toml:"token" yaml:"token"` + Admin []byte `boil:"admin" json:"admin" toml:"admin" yaml:"admin"` + WeeklyLimit types.NullDecimal `boil:"weekly_limit" json:"weekly_limit,omitempty" toml:"weekly_limit" yaml:"weekly_limit,omitempty"` + Balance types.Decimal `boil:"balance" json:"balance" toml:"balance" yaml:"balance"` + CreatedAt time.Time `boil:"created_at" json:"created_at" toml:"created_at" yaml:"created_at"` + + R *merklePoolR `boil:"-" json:"-" toml:"-" yaml:"-"` + L merklePoolL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var MerklePoolColumns = struct { + PoolID string + Token string + Admin string + WeeklyLimit string + Balance string + CreatedAt string +}{ + PoolID: "pool_id", + Token: "token", + Admin: "admin", + WeeklyLimit: "weekly_limit", + Balance: "balance", + CreatedAt: "created_at", +} + +var MerklePoolTableColumns = struct { + PoolID string + Token string + Admin string + WeeklyLimit string + Balance string + CreatedAt string +}{ + PoolID: "merkle_pools.pool_id", + Token: "merkle_pools.token", + Admin: "merkle_pools.admin", + WeeklyLimit: "merkle_pools.weekly_limit", + Balance: "merkle_pools.balance", + CreatedAt: "merkle_pools.created_at", +} + +// Generated where + +type whereHelpertypes_NullDecimal struct{ field string } + +func (w whereHelpertypes_NullDecimal) EQ(x types.NullDecimal) qm.QueryMod { + return qmhelper.WhereNullEQ(w.field, false, x) +} +func (w whereHelpertypes_NullDecimal) NEQ(x types.NullDecimal) qm.QueryMod { + return qmhelper.WhereNullEQ(w.field, true, x) +} +func (w whereHelpertypes_NullDecimal) LT(x types.NullDecimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LT, x) +} +func (w whereHelpertypes_NullDecimal) LTE(x types.NullDecimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.LTE, x) +} +func (w whereHelpertypes_NullDecimal) GT(x types.NullDecimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GT, x) +} +func (w whereHelpertypes_NullDecimal) GTE(x types.NullDecimal) qm.QueryMod { + return qmhelper.Where(w.field, qmhelper.GTE, x) +} + +func (w whereHelpertypes_NullDecimal) IsNull() qm.QueryMod { return qmhelper.WhereIsNull(w.field) } +func (w whereHelpertypes_NullDecimal) IsNotNull() qm.QueryMod { + return qmhelper.WhereIsNotNull(w.field) +} + +var MerklePoolWhere = struct { + PoolID whereHelperint + Token whereHelper__byte + Admin whereHelper__byte + WeeklyLimit whereHelpertypes_NullDecimal + Balance whereHelpertypes_Decimal + CreatedAt whereHelpertime_Time +}{ + PoolID: whereHelperint{field: "\"identity_api\".\"merkle_pools\".\"pool_id\""}, + Token: whereHelper__byte{field: "\"identity_api\".\"merkle_pools\".\"token\""}, + Admin: whereHelper__byte{field: "\"identity_api\".\"merkle_pools\".\"admin\""}, + WeeklyLimit: whereHelpertypes_NullDecimal{field: "\"identity_api\".\"merkle_pools\".\"weekly_limit\""}, + Balance: whereHelpertypes_Decimal{field: "\"identity_api\".\"merkle_pools\".\"balance\""}, + CreatedAt: whereHelpertime_Time{field: "\"identity_api\".\"merkle_pools\".\"created_at\""}, +} + +// MerklePoolRels is where relationship names are stored. +var MerklePoolRels = struct { + PoolMerkleRoots string +}{ + PoolMerkleRoots: "PoolMerkleRoots", +} + +// merklePoolR is where relationships are stored. +type merklePoolR struct { + PoolMerkleRoots MerkleRootSlice `boil:"PoolMerkleRoots" json:"PoolMerkleRoots" toml:"PoolMerkleRoots" yaml:"PoolMerkleRoots"` +} + +// NewStruct creates a new relationship struct +func (*merklePoolR) NewStruct() *merklePoolR { + return &merklePoolR{} +} + +func (o *MerklePool) GetPoolMerkleRoots() MerkleRootSlice { + if o == nil { + return nil + } + + return o.R.GetPoolMerkleRoots() +} + +func (r *merklePoolR) GetPoolMerkleRoots() MerkleRootSlice { + if r == nil { + return nil + } + + return r.PoolMerkleRoots +} + +// merklePoolL is where Load methods for each relationship are stored. +type merklePoolL struct{} + +var ( + merklePoolAllColumns = []string{"pool_id", "token", "admin", "weekly_limit", "balance", "created_at"} + merklePoolColumnsWithoutDefault = []string{"pool_id", "token", "admin", "created_at"} + merklePoolColumnsWithDefault = []string{"weekly_limit", "balance"} + merklePoolPrimaryKeyColumns = []string{"pool_id"} + merklePoolGeneratedColumns = []string{} +) + +type ( + // MerklePoolSlice is an alias for a slice of pointers to MerklePool. + // This should almost always be used instead of []MerklePool. + MerklePoolSlice []*MerklePool + // MerklePoolHook is the signature for custom MerklePool hook methods + MerklePoolHook func(context.Context, boil.ContextExecutor, *MerklePool) error + + merklePoolQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + merklePoolType = reflect.TypeOf(&MerklePool{}) + merklePoolMapping = queries.MakeStructMapping(merklePoolType) + merklePoolPrimaryKeyMapping, _ = queries.BindMapping(merklePoolType, merklePoolMapping, merklePoolPrimaryKeyColumns) + merklePoolInsertCacheMut sync.RWMutex + merklePoolInsertCache = make(map[string]insertCache) + merklePoolUpdateCacheMut sync.RWMutex + merklePoolUpdateCache = make(map[string]updateCache) + merklePoolUpsertCacheMut sync.RWMutex + merklePoolUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var merklePoolAfterSelectMu sync.Mutex +var merklePoolAfterSelectHooks []MerklePoolHook + +var merklePoolBeforeInsertMu sync.Mutex +var merklePoolBeforeInsertHooks []MerklePoolHook +var merklePoolAfterInsertMu sync.Mutex +var merklePoolAfterInsertHooks []MerklePoolHook + +var merklePoolBeforeUpdateMu sync.Mutex +var merklePoolBeforeUpdateHooks []MerklePoolHook +var merklePoolAfterUpdateMu sync.Mutex +var merklePoolAfterUpdateHooks []MerklePoolHook + +var merklePoolBeforeDeleteMu sync.Mutex +var merklePoolBeforeDeleteHooks []MerklePoolHook +var merklePoolAfterDeleteMu sync.Mutex +var merklePoolAfterDeleteHooks []MerklePoolHook + +var merklePoolBeforeUpsertMu sync.Mutex +var merklePoolBeforeUpsertHooks []MerklePoolHook +var merklePoolAfterUpsertMu sync.Mutex +var merklePoolAfterUpsertHooks []MerklePoolHook + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *MerklePool) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *MerklePool) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *MerklePool) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *MerklePool) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *MerklePool) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *MerklePool) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *MerklePool) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *MerklePool) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *MerklePool) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merklePoolAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddMerklePoolHook registers your hook function for all future operations. +func AddMerklePoolHook(hookPoint boil.HookPoint, merklePoolHook MerklePoolHook) { + switch hookPoint { + case boil.AfterSelectHook: + merklePoolAfterSelectMu.Lock() + merklePoolAfterSelectHooks = append(merklePoolAfterSelectHooks, merklePoolHook) + merklePoolAfterSelectMu.Unlock() + case boil.BeforeInsertHook: + merklePoolBeforeInsertMu.Lock() + merklePoolBeforeInsertHooks = append(merklePoolBeforeInsertHooks, merklePoolHook) + merklePoolBeforeInsertMu.Unlock() + case boil.AfterInsertHook: + merklePoolAfterInsertMu.Lock() + merklePoolAfterInsertHooks = append(merklePoolAfterInsertHooks, merklePoolHook) + merklePoolAfterInsertMu.Unlock() + case boil.BeforeUpdateHook: + merklePoolBeforeUpdateMu.Lock() + merklePoolBeforeUpdateHooks = append(merklePoolBeforeUpdateHooks, merklePoolHook) + merklePoolBeforeUpdateMu.Unlock() + case boil.AfterUpdateHook: + merklePoolAfterUpdateMu.Lock() + merklePoolAfterUpdateHooks = append(merklePoolAfterUpdateHooks, merklePoolHook) + merklePoolAfterUpdateMu.Unlock() + case boil.BeforeDeleteHook: + merklePoolBeforeDeleteMu.Lock() + merklePoolBeforeDeleteHooks = append(merklePoolBeforeDeleteHooks, merklePoolHook) + merklePoolBeforeDeleteMu.Unlock() + case boil.AfterDeleteHook: + merklePoolAfterDeleteMu.Lock() + merklePoolAfterDeleteHooks = append(merklePoolAfterDeleteHooks, merklePoolHook) + merklePoolAfterDeleteMu.Unlock() + case boil.BeforeUpsertHook: + merklePoolBeforeUpsertMu.Lock() + merklePoolBeforeUpsertHooks = append(merklePoolBeforeUpsertHooks, merklePoolHook) + merklePoolBeforeUpsertMu.Unlock() + case boil.AfterUpsertHook: + merklePoolAfterUpsertMu.Lock() + merklePoolAfterUpsertHooks = append(merklePoolAfterUpsertHooks, merklePoolHook) + merklePoolAfterUpsertMu.Unlock() + } +} + +// One returns a single merklePool record from the query. +func (q merklePoolQuery) One(ctx context.Context, exec boil.ContextExecutor) (*MerklePool, error) { + o := &MerklePool{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: failed to execute a one query for merkle_pools") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all MerklePool records from the query. +func (q merklePoolQuery) All(ctx context.Context, exec boil.ContextExecutor) (MerklePoolSlice, error) { + var o []*MerklePool + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "models: failed to assign all query results to MerklePool slice") + } + + if len(merklePoolAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all MerklePool records in the query. +func (q merklePoolQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "models: failed to count merkle_pools rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q merklePoolQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "models: failed to check if merkle_pools exists") + } + + return count > 0, nil +} + +// PoolMerkleRoots retrieves all the merkle_root's MerkleRoots with an executor via pool_id column. +func (o *MerklePool) PoolMerkleRoots(mods ...qm.QueryMod) merkleRootQuery { + var queryMods []qm.QueryMod + if len(mods) != 0 { + queryMods = append(queryMods, mods...) + } + + queryMods = append(queryMods, + qm.Where("\"identity_api\".\"merkle_roots\".\"pool_id\"=?", o.PoolID), + ) + + return MerkleRoots(queryMods...) +} + +// LoadPoolMerkleRoots allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for a 1-M or N-M relationship. +func (merklePoolL) LoadPoolMerkleRoots(ctx context.Context, e boil.ContextExecutor, singular bool, maybeMerklePool interface{}, mods queries.Applicator) error { + var slice []*MerklePool + var object *MerklePool + + if singular { + var ok bool + object, ok = maybeMerklePool.(*MerklePool) + if !ok { + object = new(MerklePool) + ok = queries.SetFromEmbeddedStruct(&object, &maybeMerklePool) + if !ok { + return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeMerklePool)) + } + } + } else { + s, ok := maybeMerklePool.(*[]*MerklePool) + if ok { + slice = *s + } else { + ok = queries.SetFromEmbeddedStruct(&slice, maybeMerklePool) + if !ok { + return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeMerklePool)) + } + } + } + + args := make(map[interface{}]struct{}) + if singular { + if object.R == nil { + object.R = &merklePoolR{} + } + args[object.PoolID] = struct{}{} + } else { + for _, obj := range slice { + if obj.R == nil { + obj.R = &merklePoolR{} + } + args[obj.PoolID] = struct{}{} + } + } + + if len(args) == 0 { + return nil + } + + argsSlice := make([]interface{}, len(args)) + i := 0 + for arg := range args { + argsSlice[i] = arg + i++ + } + + query := NewQuery( + qm.From(`identity_api.merkle_roots`), + qm.WhereIn(`identity_api.merkle_roots.pool_id in ?`, argsSlice...), + ) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load merkle_roots") + } + + var resultSlice []*MerkleRoot + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice merkle_roots") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results in eager load on merkle_roots") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for merkle_roots") + } + + if len(merkleRootAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + if singular { + object.R.PoolMerkleRoots = resultSlice + for _, foreign := range resultSlice { + if foreign.R == nil { + foreign.R = &merkleRootR{} + } + foreign.R.Pool = object + } + return nil + } + + for _, foreign := range resultSlice { + for _, local := range slice { + if local.PoolID == foreign.PoolID { + local.R.PoolMerkleRoots = append(local.R.PoolMerkleRoots, foreign) + if foreign.R == nil { + foreign.R = &merkleRootR{} + } + foreign.R.Pool = local + break + } + } + } + + return nil +} + +// AddPoolMerkleRoots adds the given related objects to the existing relationships +// of the merkle_pool, optionally inserting them as new records. +// Appends related to o.R.PoolMerkleRoots. +// Sets related.R.Pool appropriately. +func (o *MerklePool) AddPoolMerkleRoots(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*MerkleRoot) error { + var err error + for _, rel := range related { + if insert { + rel.PoolID = o.PoolID + if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } else { + updateQuery := fmt.Sprintf( + "UPDATE \"identity_api\".\"merkle_roots\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"pool_id"}), + strmangle.WhereClause("\"", "\"", 2, merkleRootPrimaryKeyColumns), + ) + values := []interface{}{o.PoolID, rel.PoolID, rel.Epoch} + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, updateQuery) + fmt.Fprintln(writer, values) + } + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update foreign table") + } + + rel.PoolID = o.PoolID + } + } + + if o.R == nil { + o.R = &merklePoolR{ + PoolMerkleRoots: related, + } + } else { + o.R.PoolMerkleRoots = append(o.R.PoolMerkleRoots, related...) + } + + for _, rel := range related { + if rel.R == nil { + rel.R = &merkleRootR{ + Pool: o, + } + } else { + rel.R.Pool = o + } + } + return nil +} + +// MerklePools retrieves all the records using an executor. +func MerklePools(mods ...qm.QueryMod) merklePoolQuery { + mods = append(mods, qm.From("\"identity_api\".\"merkle_pools\"")) + q := NewQuery(mods...) + if len(queries.GetSelect(q)) == 0 { + queries.SetSelect(q, []string{"\"identity_api\".\"merkle_pools\".*"}) + } + + return merklePoolQuery{q} +} + +// FindMerklePool retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindMerklePool(ctx context.Context, exec boil.ContextExecutor, poolID int, selectCols ...string) (*MerklePool, error) { + merklePoolObj := &MerklePool{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"identity_api\".\"merkle_pools\" where \"pool_id\"=$1", sel, + ) + + q := queries.Raw(query, poolID) + + err := q.Bind(ctx, exec, merklePoolObj) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: unable to select from merkle_pools") + } + + if err = merklePoolObj.doAfterSelectHooks(ctx, exec); err != nil { + return merklePoolObj, err + } + + return merklePoolObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *MerklePool) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("models: no merkle_pools provided for insertion") + } + + var err error + if !boil.TimestampsAreSkipped(ctx) { + currTime := time.Now().In(boil.GetLocation()) + + if o.CreatedAt.IsZero() { + o.CreatedAt = currTime + } + } + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merklePoolColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + merklePoolInsertCacheMut.RLock() + cache, cached := merklePoolInsertCache[key] + merklePoolInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + merklePoolAllColumns, + merklePoolColumnsWithDefault, + merklePoolColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(merklePoolType, merklePoolMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(merklePoolType, merklePoolMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"identity_api\".\"merkle_pools\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"identity_api\".\"merkle_pools\" %sDEFAULT VALUES%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + + if err != nil { + return errors.Wrap(err, "models: unable to insert into merkle_pools") + } + + if !cached { + merklePoolInsertCacheMut.Lock() + merklePoolInsertCache[key] = cache + merklePoolInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the MerklePool. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *MerklePool) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + merklePoolUpdateCacheMut.RLock() + cache, cached := merklePoolUpdateCache[key] + merklePoolUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + merklePoolAllColumns, + merklePoolPrimaryKeyColumns, + ) + + if !columns.IsWhitelist() { + wl = strmangle.SetComplement(wl, []string{"created_at"}) + } + if len(wl) == 0 { + return 0, errors.New("models: unable to update merkle_pools, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"identity_api\".\"merkle_pools\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, wl), + strmangle.WhereClause("\"", "\"", len(wl)+1, merklePoolPrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(merklePoolType, merklePoolMapping, append(wl, merklePoolPrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, values) + } + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update merkle_pools row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by update for merkle_pools") + } + + if !cached { + merklePoolUpdateCacheMut.Lock() + merklePoolUpdateCache[key] = cache + merklePoolUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q merklePoolQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all for merkle_pools") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected for merkle_pools") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o MerklePoolSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("models: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merklePoolPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"identity_api\".\"merkle_pools\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, merklePoolPrimaryKeyColumns, len(o))) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all in merklePool slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all merklePool") + } + return rowsAff, nil +} + +// Upsert attempts an insert using an executor, and does an update or ignore on conflict. +// See boil.Columns documentation for how to properly use updateColumns and insertColumns. +func (o *MerklePool) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns, opts ...UpsertOptionFunc) error { + if o == nil { + return errors.New("models: no merkle_pools provided for upsert") + } + if !boil.TimestampsAreSkipped(ctx) { + currTime := time.Now().In(boil.GetLocation()) + + if o.CreatedAt.IsZero() { + o.CreatedAt = currTime + } + } + + if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merklePoolColumnsWithDefault, o) + + // Build cache key in-line uglily - mysql vs psql problems + buf := strmangle.GetBuffer() + if updateOnConflict { + buf.WriteByte('t') + } else { + buf.WriteByte('f') + } + buf.WriteByte('.') + for _, c := range conflictColumns { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(updateColumns.Kind)) + for _, c := range updateColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(insertColumns.Kind)) + for _, c := range insertColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + for _, c := range nzDefaults { + buf.WriteString(c) + } + key := buf.String() + strmangle.PutBuffer(buf) + + merklePoolUpsertCacheMut.RLock() + cache, cached := merklePoolUpsertCache[key] + merklePoolUpsertCacheMut.RUnlock() + + var err error + + if !cached { + insert, _ := insertColumns.InsertColumnSet( + merklePoolAllColumns, + merklePoolColumnsWithDefault, + merklePoolColumnsWithoutDefault, + nzDefaults, + ) + + update := updateColumns.UpdateColumnSet( + merklePoolAllColumns, + merklePoolPrimaryKeyColumns, + ) + + if updateOnConflict && len(update) == 0 { + return errors.New("models: unable to upsert merkle_pools, could not build update column list") + } + + ret := strmangle.SetComplement(merklePoolAllColumns, strmangle.SetIntersect(insert, update)) + + conflict := conflictColumns + if len(conflict) == 0 && updateOnConflict && len(update) != 0 { + if len(merklePoolPrimaryKeyColumns) == 0 { + return errors.New("models: unable to upsert merkle_pools, could not build conflict column list") + } + + conflict = make([]string, len(merklePoolPrimaryKeyColumns)) + copy(conflict, merklePoolPrimaryKeyColumns) + } + cache.query = buildUpsertQueryPostgres(dialect, "\"identity_api\".\"merkle_pools\"", updateOnConflict, ret, update, conflict, insert, opts...) + + cache.valueMapping, err = queries.BindMapping(merklePoolType, merklePoolMapping, insert) + if err != nil { + return err + } + if len(ret) != 0 { + cache.retMapping, err = queries.BindMapping(merklePoolType, merklePoolMapping, ret) + if err != nil { + return err + } + } + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + var returns []interface{} + if len(cache.retMapping) != 0 { + returns = queries.PtrsFromMapping(value, cache.retMapping) + } + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) + if errors.Is(err, sql.ErrNoRows) { + err = nil // Postgres doesn't return anything when there's no update + } + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + if err != nil { + return errors.Wrap(err, "models: unable to upsert merkle_pools") + } + + if !cached { + merklePoolUpsertCacheMut.Lock() + merklePoolUpsertCache[key] = cache + merklePoolUpsertCacheMut.Unlock() + } + + return o.doAfterUpsertHooks(ctx, exec) +} + +// Delete deletes a single MerklePool record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *MerklePool) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("models: no MerklePool provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), merklePoolPrimaryKeyMapping) + sql := "DELETE FROM \"identity_api\".\"merkle_pools\" WHERE \"pool_id\"=$1" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete from merkle_pools") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by delete for merkle_pools") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q merklePoolQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("models: no merklePoolQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merkle_pools") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_pools") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o MerklePoolSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(merklePoolBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merklePoolPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"identity_api\".\"merkle_pools\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merklePoolPrimaryKeyColumns, len(o)) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merklePool slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_pools") + } + + if len(merklePoolAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *MerklePool) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindMerklePool(ctx, exec, o.PoolID) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *MerklePoolSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := MerklePoolSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merklePoolPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"identity_api\".\"merkle_pools\".* FROM \"identity_api\".\"merkle_pools\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merklePoolPrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "models: unable to reload all in MerklePoolSlice") + } + + *o = slice + + return nil +} + +// MerklePoolExists checks if the MerklePool row exists. +func MerklePoolExists(ctx context.Context, exec boil.ContextExecutor, poolID int) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"identity_api\".\"merkle_pools\" where \"pool_id\"=$1 limit 1)" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, poolID) + } + row := exec.QueryRowContext(ctx, sql, poolID) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "models: unable to check if merkle_pools exists") + } + + return exists, nil +} + +// Exists checks if the MerklePool row exists. +func (o *MerklePool) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + return MerklePoolExists(ctx, exec, o.PoolID) +} diff --git a/models/merkle_roots.go b/models/merkle_roots.go new file mode 100644 index 00000000..69c40e8f --- /dev/null +++ b/models/merkle_roots.go @@ -0,0 +1,1176 @@ +// Code generated by SQLBoiler 4.19.5 (https://github.com/aarondl/sqlboiler). DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package models + +import ( + "context" + "database/sql" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + "time" + + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/aarondl/sqlboiler/v4/queries" + "github.com/aarondl/sqlboiler/v4/queries/qm" + "github.com/aarondl/sqlboiler/v4/queries/qmhelper" + "github.com/aarondl/sqlboiler/v4/types" + "github.com/aarondl/strmangle" + "github.com/friendsofgo/errors" +) + +// MerkleRoot is an object representing the database table. +type MerkleRoot struct { + PoolID int `boil:"pool_id" json:"pool_id" toml:"pool_id" yaml:"pool_id"` + Epoch int `boil:"epoch" json:"epoch" toml:"epoch" yaml:"epoch"` + Root []byte `boil:"root" json:"root" toml:"root" yaml:"root"` + Allocation types.Decimal `boil:"allocation" json:"allocation" toml:"allocation" yaml:"allocation"` + TotalClaimed types.Decimal `boil:"total_claimed" json:"total_claimed" toml:"total_claimed" yaml:"total_claimed"` + ClaimCount int `boil:"claim_count" json:"claim_count" toml:"claim_count" yaml:"claim_count"` + RecipientCount int `boil:"recipient_count" json:"recipient_count" toml:"recipient_count" yaml:"recipient_count"` + ProofsURI string `boil:"proofs_uri" json:"proofs_uri" toml:"proofs_uri" yaml:"proofs_uri"` + SetAt time.Time `boil:"set_at" json:"set_at" toml:"set_at" yaml:"set_at"` + + R *merkleRootR `boil:"-" json:"-" toml:"-" yaml:"-"` + L merkleRootL `boil:"-" json:"-" toml:"-" yaml:"-"` +} + +var MerkleRootColumns = struct { + PoolID string + Epoch string + Root string + Allocation string + TotalClaimed string + ClaimCount string + RecipientCount string + ProofsURI string + SetAt string +}{ + PoolID: "pool_id", + Epoch: "epoch", + Root: "root", + Allocation: "allocation", + TotalClaimed: "total_claimed", + ClaimCount: "claim_count", + RecipientCount: "recipient_count", + ProofsURI: "proofs_uri", + SetAt: "set_at", +} + +var MerkleRootTableColumns = struct { + PoolID string + Epoch string + Root string + Allocation string + TotalClaimed string + ClaimCount string + RecipientCount string + ProofsURI string + SetAt string +}{ + PoolID: "merkle_roots.pool_id", + Epoch: "merkle_roots.epoch", + Root: "merkle_roots.root", + Allocation: "merkle_roots.allocation", + TotalClaimed: "merkle_roots.total_claimed", + ClaimCount: "merkle_roots.claim_count", + RecipientCount: "merkle_roots.recipient_count", + ProofsURI: "merkle_roots.proofs_uri", + SetAt: "merkle_roots.set_at", +} + +// Generated where + +var MerkleRootWhere = struct { + PoolID whereHelperint + Epoch whereHelperint + Root whereHelper__byte + Allocation whereHelpertypes_Decimal + TotalClaimed whereHelpertypes_Decimal + ClaimCount whereHelperint + RecipientCount whereHelperint + ProofsURI whereHelperstring + SetAt whereHelpertime_Time +}{ + PoolID: whereHelperint{field: "\"identity_api\".\"merkle_roots\".\"pool_id\""}, + Epoch: whereHelperint{field: "\"identity_api\".\"merkle_roots\".\"epoch\""}, + Root: whereHelper__byte{field: "\"identity_api\".\"merkle_roots\".\"root\""}, + Allocation: whereHelpertypes_Decimal{field: "\"identity_api\".\"merkle_roots\".\"allocation\""}, + TotalClaimed: whereHelpertypes_Decimal{field: "\"identity_api\".\"merkle_roots\".\"total_claimed\""}, + ClaimCount: whereHelperint{field: "\"identity_api\".\"merkle_roots\".\"claim_count\""}, + RecipientCount: whereHelperint{field: "\"identity_api\".\"merkle_roots\".\"recipient_count\""}, + ProofsURI: whereHelperstring{field: "\"identity_api\".\"merkle_roots\".\"proofs_uri\""}, + SetAt: whereHelpertime_Time{field: "\"identity_api\".\"merkle_roots\".\"set_at\""}, +} + +// MerkleRootRels is where relationship names are stored. +var MerkleRootRels = struct { + Pool string +}{ + Pool: "Pool", +} + +// merkleRootR is where relationships are stored. +type merkleRootR struct { + Pool *MerklePool `boil:"Pool" json:"Pool" toml:"Pool" yaml:"Pool"` +} + +// NewStruct creates a new relationship struct +func (*merkleRootR) NewStruct() *merkleRootR { + return &merkleRootR{} +} + +func (o *MerkleRoot) GetPool() *MerklePool { + if o == nil { + return nil + } + + return o.R.GetPool() +} + +func (r *merkleRootR) GetPool() *MerklePool { + if r == nil { + return nil + } + + return r.Pool +} + +// merkleRootL is where Load methods for each relationship are stored. +type merkleRootL struct{} + +var ( + merkleRootAllColumns = []string{"pool_id", "epoch", "root", "allocation", "total_claimed", "claim_count", "recipient_count", "proofs_uri", "set_at"} + merkleRootColumnsWithoutDefault = []string{"pool_id", "epoch", "root", "allocation", "proofs_uri", "set_at"} + merkleRootColumnsWithDefault = []string{"total_claimed", "claim_count", "recipient_count"} + merkleRootPrimaryKeyColumns = []string{"pool_id", "epoch"} + merkleRootGeneratedColumns = []string{} +) + +type ( + // MerkleRootSlice is an alias for a slice of pointers to MerkleRoot. + // This should almost always be used instead of []MerkleRoot. + MerkleRootSlice []*MerkleRoot + // MerkleRootHook is the signature for custom MerkleRoot hook methods + MerkleRootHook func(context.Context, boil.ContextExecutor, *MerkleRoot) error + + merkleRootQuery struct { + *queries.Query + } +) + +// Cache for insert, update and upsert +var ( + merkleRootType = reflect.TypeOf(&MerkleRoot{}) + merkleRootMapping = queries.MakeStructMapping(merkleRootType) + merkleRootPrimaryKeyMapping, _ = queries.BindMapping(merkleRootType, merkleRootMapping, merkleRootPrimaryKeyColumns) + merkleRootInsertCacheMut sync.RWMutex + merkleRootInsertCache = make(map[string]insertCache) + merkleRootUpdateCacheMut sync.RWMutex + merkleRootUpdateCache = make(map[string]updateCache) + merkleRootUpsertCacheMut sync.RWMutex + merkleRootUpsertCache = make(map[string]insertCache) +) + +var ( + // Force time package dependency for automated UpdatedAt/CreatedAt. + _ = time.Second + // Force qmhelper dependency for where clause generation (which doesn't + // always happen) + _ = qmhelper.Where +) + +var merkleRootAfterSelectMu sync.Mutex +var merkleRootAfterSelectHooks []MerkleRootHook + +var merkleRootBeforeInsertMu sync.Mutex +var merkleRootBeforeInsertHooks []MerkleRootHook +var merkleRootAfterInsertMu sync.Mutex +var merkleRootAfterInsertHooks []MerkleRootHook + +var merkleRootBeforeUpdateMu sync.Mutex +var merkleRootBeforeUpdateHooks []MerkleRootHook +var merkleRootAfterUpdateMu sync.Mutex +var merkleRootAfterUpdateHooks []MerkleRootHook + +var merkleRootBeforeDeleteMu sync.Mutex +var merkleRootBeforeDeleteHooks []MerkleRootHook +var merkleRootAfterDeleteMu sync.Mutex +var merkleRootAfterDeleteHooks []MerkleRootHook + +var merkleRootBeforeUpsertMu sync.Mutex +var merkleRootBeforeUpsertHooks []MerkleRootHook +var merkleRootAfterUpsertMu sync.Mutex +var merkleRootAfterUpsertHooks []MerkleRootHook + +// doAfterSelectHooks executes all "after Select" hooks. +func (o *MerkleRoot) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootAfterSelectHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeInsertHooks executes all "before insert" hooks. +func (o *MerkleRoot) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootBeforeInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterInsertHooks executes all "after Insert" hooks. +func (o *MerkleRoot) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootAfterInsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpdateHooks executes all "before Update" hooks. +func (o *MerkleRoot) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootBeforeUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpdateHooks executes all "after Update" hooks. +func (o *MerkleRoot) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootAfterUpdateHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeDeleteHooks executes all "before Delete" hooks. +func (o *MerkleRoot) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootBeforeDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterDeleteHooks executes all "after Delete" hooks. +func (o *MerkleRoot) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootAfterDeleteHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doBeforeUpsertHooks executes all "before Upsert" hooks. +func (o *MerkleRoot) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootBeforeUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// doAfterUpsertHooks executes all "after Upsert" hooks. +func (o *MerkleRoot) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { + if boil.HooksAreSkipped(ctx) { + return nil + } + + for _, hook := range merkleRootAfterUpsertHooks { + if err := hook(ctx, exec, o); err != nil { + return err + } + } + + return nil +} + +// AddMerkleRootHook registers your hook function for all future operations. +func AddMerkleRootHook(hookPoint boil.HookPoint, merkleRootHook MerkleRootHook) { + switch hookPoint { + case boil.AfterSelectHook: + merkleRootAfterSelectMu.Lock() + merkleRootAfterSelectHooks = append(merkleRootAfterSelectHooks, merkleRootHook) + merkleRootAfterSelectMu.Unlock() + case boil.BeforeInsertHook: + merkleRootBeforeInsertMu.Lock() + merkleRootBeforeInsertHooks = append(merkleRootBeforeInsertHooks, merkleRootHook) + merkleRootBeforeInsertMu.Unlock() + case boil.AfterInsertHook: + merkleRootAfterInsertMu.Lock() + merkleRootAfterInsertHooks = append(merkleRootAfterInsertHooks, merkleRootHook) + merkleRootAfterInsertMu.Unlock() + case boil.BeforeUpdateHook: + merkleRootBeforeUpdateMu.Lock() + merkleRootBeforeUpdateHooks = append(merkleRootBeforeUpdateHooks, merkleRootHook) + merkleRootBeforeUpdateMu.Unlock() + case boil.AfterUpdateHook: + merkleRootAfterUpdateMu.Lock() + merkleRootAfterUpdateHooks = append(merkleRootAfterUpdateHooks, merkleRootHook) + merkleRootAfterUpdateMu.Unlock() + case boil.BeforeDeleteHook: + merkleRootBeforeDeleteMu.Lock() + merkleRootBeforeDeleteHooks = append(merkleRootBeforeDeleteHooks, merkleRootHook) + merkleRootBeforeDeleteMu.Unlock() + case boil.AfterDeleteHook: + merkleRootAfterDeleteMu.Lock() + merkleRootAfterDeleteHooks = append(merkleRootAfterDeleteHooks, merkleRootHook) + merkleRootAfterDeleteMu.Unlock() + case boil.BeforeUpsertHook: + merkleRootBeforeUpsertMu.Lock() + merkleRootBeforeUpsertHooks = append(merkleRootBeforeUpsertHooks, merkleRootHook) + merkleRootBeforeUpsertMu.Unlock() + case boil.AfterUpsertHook: + merkleRootAfterUpsertMu.Lock() + merkleRootAfterUpsertHooks = append(merkleRootAfterUpsertHooks, merkleRootHook) + merkleRootAfterUpsertMu.Unlock() + } +} + +// One returns a single merkleRoot record from the query. +func (q merkleRootQuery) One(ctx context.Context, exec boil.ContextExecutor) (*MerkleRoot, error) { + o := &MerkleRoot{} + + queries.SetLimit(q.Query, 1) + + err := q.Bind(ctx, exec, o) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: failed to execute a one query for merkle_roots") + } + + if err := o.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + + return o, nil +} + +// All returns all MerkleRoot records from the query. +func (q merkleRootQuery) All(ctx context.Context, exec boil.ContextExecutor) (MerkleRootSlice, error) { + var o []*MerkleRoot + + err := q.Bind(ctx, exec, &o) + if err != nil { + return nil, errors.Wrap(err, "models: failed to assign all query results to MerkleRoot slice") + } + + if len(merkleRootAfterSelectHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterSelectHooks(ctx, exec); err != nil { + return o, err + } + } + } + + return o, nil +} + +// Count returns the count of all MerkleRoot records in the query. +func (q merkleRootQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return 0, errors.Wrap(err, "models: failed to count merkle_roots rows") + } + + return count, nil +} + +// Exists checks if the row exists in the table. +func (q merkleRootQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + var count int64 + + queries.SetSelect(q.Query, nil) + queries.SetCount(q.Query) + queries.SetLimit(q.Query, 1) + + err := q.Query.QueryRowContext(ctx, exec).Scan(&count) + if err != nil { + return false, errors.Wrap(err, "models: failed to check if merkle_roots exists") + } + + return count > 0, nil +} + +// Pool pointed to by the foreign key. +func (o *MerkleRoot) Pool(mods ...qm.QueryMod) merklePoolQuery { + queryMods := []qm.QueryMod{ + qm.Where("\"pool_id\" = ?", o.PoolID), + } + + queryMods = append(queryMods, mods...) + + return MerklePools(queryMods...) +} + +// LoadPool allows an eager lookup of values, cached into the +// loaded structs of the objects. This is for an N-1 relationship. +func (merkleRootL) LoadPool(ctx context.Context, e boil.ContextExecutor, singular bool, maybeMerkleRoot interface{}, mods queries.Applicator) error { + var slice []*MerkleRoot + var object *MerkleRoot + + if singular { + var ok bool + object, ok = maybeMerkleRoot.(*MerkleRoot) + if !ok { + object = new(MerkleRoot) + ok = queries.SetFromEmbeddedStruct(&object, &maybeMerkleRoot) + if !ok { + return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeMerkleRoot)) + } + } + } else { + s, ok := maybeMerkleRoot.(*[]*MerkleRoot) + if ok { + slice = *s + } else { + ok = queries.SetFromEmbeddedStruct(&slice, maybeMerkleRoot) + if !ok { + return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeMerkleRoot)) + } + } + } + + args := make(map[interface{}]struct{}) + if singular { + if object.R == nil { + object.R = &merkleRootR{} + } + args[object.PoolID] = struct{}{} + + } else { + for _, obj := range slice { + if obj.R == nil { + obj.R = &merkleRootR{} + } + + args[obj.PoolID] = struct{}{} + + } + } + + if len(args) == 0 { + return nil + } + + argsSlice := make([]interface{}, len(args)) + i := 0 + for arg := range args { + argsSlice[i] = arg + i++ + } + + query := NewQuery( + qm.From(`identity_api.merkle_pools`), + qm.WhereIn(`identity_api.merkle_pools.pool_id in ?`, argsSlice...), + ) + if mods != nil { + mods.Apply(query) + } + + results, err := query.QueryContext(ctx, e) + if err != nil { + return errors.Wrap(err, "failed to eager load MerklePool") + } + + var resultSlice []*MerklePool + if err = queries.Bind(results, &resultSlice); err != nil { + return errors.Wrap(err, "failed to bind eager loaded slice MerklePool") + } + + if err = results.Close(); err != nil { + return errors.Wrap(err, "failed to close results of eager load for merkle_pools") + } + if err = results.Err(); err != nil { + return errors.Wrap(err, "error occurred during iteration of eager loaded relations for merkle_pools") + } + + if len(merklePoolAfterSelectHooks) != 0 { + for _, obj := range resultSlice { + if err := obj.doAfterSelectHooks(ctx, e); err != nil { + return err + } + } + } + + if len(resultSlice) == 0 { + return nil + } + + if singular { + foreign := resultSlice[0] + object.R.Pool = foreign + if foreign.R == nil { + foreign.R = &merklePoolR{} + } + foreign.R.PoolMerkleRoots = append(foreign.R.PoolMerkleRoots, object) + return nil + } + + for _, local := range slice { + for _, foreign := range resultSlice { + if local.PoolID == foreign.PoolID { + local.R.Pool = foreign + if foreign.R == nil { + foreign.R = &merklePoolR{} + } + foreign.R.PoolMerkleRoots = append(foreign.R.PoolMerkleRoots, local) + break + } + } + } + + return nil +} + +// SetPool of the merkleRoot to the related item. +// Sets o.R.Pool to related. +// Adds o to related.R.PoolMerkleRoots. +func (o *MerkleRoot) SetPool(ctx context.Context, exec boil.ContextExecutor, insert bool, related *MerklePool) error { + var err error + if insert { + if err = related.Insert(ctx, exec, boil.Infer()); err != nil { + return errors.Wrap(err, "failed to insert into foreign table") + } + } + + updateQuery := fmt.Sprintf( + "UPDATE \"identity_api\".\"merkle_roots\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, []string{"pool_id"}), + strmangle.WhereClause("\"", "\"", 2, merkleRootPrimaryKeyColumns), + ) + values := []interface{}{related.PoolID, o.PoolID, o.Epoch} + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, updateQuery) + fmt.Fprintln(writer, values) + } + if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { + return errors.Wrap(err, "failed to update local table") + } + + o.PoolID = related.PoolID + if o.R == nil { + o.R = &merkleRootR{ + Pool: related, + } + } else { + o.R.Pool = related + } + + if related.R == nil { + related.R = &merklePoolR{ + PoolMerkleRoots: MerkleRootSlice{o}, + } + } else { + related.R.PoolMerkleRoots = append(related.R.PoolMerkleRoots, o) + } + + return nil +} + +// MerkleRoots retrieves all the records using an executor. +func MerkleRoots(mods ...qm.QueryMod) merkleRootQuery { + mods = append(mods, qm.From("\"identity_api\".\"merkle_roots\"")) + q := NewQuery(mods...) + if len(queries.GetSelect(q)) == 0 { + queries.SetSelect(q, []string{"\"identity_api\".\"merkle_roots\".*"}) + } + + return merkleRootQuery{q} +} + +// FindMerkleRoot retrieves a single record by ID with an executor. +// If selectCols is empty Find will return all columns. +func FindMerkleRoot(ctx context.Context, exec boil.ContextExecutor, poolID int, epoch int, selectCols ...string) (*MerkleRoot, error) { + merkleRootObj := &MerkleRoot{} + + sel := "*" + if len(selectCols) > 0 { + sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") + } + query := fmt.Sprintf( + "select %s from \"identity_api\".\"merkle_roots\" where \"pool_id\"=$1 AND \"epoch\"=$2", sel, + ) + + q := queries.Raw(query, poolID, epoch) + + err := q.Bind(ctx, exec, merkleRootObj) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, sql.ErrNoRows + } + return nil, errors.Wrap(err, "models: unable to select from merkle_roots") + } + + if err = merkleRootObj.doAfterSelectHooks(ctx, exec); err != nil { + return merkleRootObj, err + } + + return merkleRootObj, nil +} + +// Insert a single record using an executor. +// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. +func (o *MerkleRoot) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { + if o == nil { + return errors.New("models: no merkle_roots provided for insertion") + } + + var err error + + if err := o.doBeforeInsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merkleRootColumnsWithDefault, o) + + key := makeCacheKey(columns, nzDefaults) + merkleRootInsertCacheMut.RLock() + cache, cached := merkleRootInsertCache[key] + merkleRootInsertCacheMut.RUnlock() + + if !cached { + wl, returnColumns := columns.InsertColumnSet( + merkleRootAllColumns, + merkleRootColumnsWithDefault, + merkleRootColumnsWithoutDefault, + nzDefaults, + ) + + cache.valueMapping, err = queries.BindMapping(merkleRootType, merkleRootMapping, wl) + if err != nil { + return err + } + cache.retMapping, err = queries.BindMapping(merkleRootType, merkleRootMapping, returnColumns) + if err != nil { + return err + } + if len(wl) != 0 { + cache.query = fmt.Sprintf("INSERT INTO \"identity_api\".\"merkle_roots\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) + } else { + cache.query = "INSERT INTO \"identity_api\".\"merkle_roots\" %sDEFAULT VALUES%s" + } + + var queryOutput, queryReturning string + + if len(cache.retMapping) != 0 { + queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) + } + + cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + + if err != nil { + return errors.Wrap(err, "models: unable to insert into merkle_roots") + } + + if !cached { + merkleRootInsertCacheMut.Lock() + merkleRootInsertCache[key] = cache + merkleRootInsertCacheMut.Unlock() + } + + return o.doAfterInsertHooks(ctx, exec) +} + +// Update uses an executor to update the MerkleRoot. +// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. +// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. +func (o *MerkleRoot) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { + var err error + if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { + return 0, err + } + key := makeCacheKey(columns, nil) + merkleRootUpdateCacheMut.RLock() + cache, cached := merkleRootUpdateCache[key] + merkleRootUpdateCacheMut.RUnlock() + + if !cached { + wl := columns.UpdateColumnSet( + merkleRootAllColumns, + merkleRootPrimaryKeyColumns, + ) + + if !columns.IsWhitelist() { + wl = strmangle.SetComplement(wl, []string{"created_at"}) + } + if len(wl) == 0 { + return 0, errors.New("models: unable to update merkle_roots, could not build whitelist") + } + + cache.query = fmt.Sprintf("UPDATE \"identity_api\".\"merkle_roots\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, wl), + strmangle.WhereClause("\"", "\"", len(wl)+1, merkleRootPrimaryKeyColumns), + ) + cache.valueMapping, err = queries.BindMapping(merkleRootType, merkleRootMapping, append(wl, merkleRootPrimaryKeyColumns...)) + if err != nil { + return 0, err + } + } + + values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, values) + } + var result sql.Result + result, err = exec.ExecContext(ctx, cache.query, values...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update merkle_roots row") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by update for merkle_roots") + } + + if !cached { + merkleRootUpdateCacheMut.Lock() + merkleRootUpdateCache[key] = cache + merkleRootUpdateCacheMut.Unlock() + } + + return rowsAff, o.doAfterUpdateHooks(ctx, exec) +} + +// UpdateAll updates all rows with the specified column values. +func (q merkleRootQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + queries.SetUpdate(q.Query, cols) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all for merkle_roots") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected for merkle_roots") + } + + return rowsAff, nil +} + +// UpdateAll updates all rows with the specified column values, using an executor. +func (o MerkleRootSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { + ln := int64(len(o)) + if ln == 0 { + return 0, nil + } + + if len(cols) == 0 { + return 0, errors.New("models: update all requires at least one column argument") + } + + colNames := make([]string, len(cols)) + args := make([]interface{}, len(cols)) + + i := 0 + for name, value := range cols { + colNames[i] = name + args[i] = value + i++ + } + + // Append all of the primary key values for each column + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleRootPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := fmt.Sprintf("UPDATE \"identity_api\".\"merkle_roots\" SET %s WHERE %s", + strmangle.SetParamNames("\"", "\"", 1, colNames), + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, merkleRootPrimaryKeyColumns, len(o))) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to update all in merkleRoot slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all merkleRoot") + } + return rowsAff, nil +} + +// Upsert attempts an insert using an executor, and does an update or ignore on conflict. +// See boil.Columns documentation for how to properly use updateColumns and insertColumns. +func (o *MerkleRoot) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns, opts ...UpsertOptionFunc) error { + if o == nil { + return errors.New("models: no merkle_roots provided for upsert") + } + + if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { + return err + } + + nzDefaults := queries.NonZeroDefaultSet(merkleRootColumnsWithDefault, o) + + // Build cache key in-line uglily - mysql vs psql problems + buf := strmangle.GetBuffer() + if updateOnConflict { + buf.WriteByte('t') + } else { + buf.WriteByte('f') + } + buf.WriteByte('.') + for _, c := range conflictColumns { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(updateColumns.Kind)) + for _, c := range updateColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + buf.WriteString(strconv.Itoa(insertColumns.Kind)) + for _, c := range insertColumns.Cols { + buf.WriteString(c) + } + buf.WriteByte('.') + for _, c := range nzDefaults { + buf.WriteString(c) + } + key := buf.String() + strmangle.PutBuffer(buf) + + merkleRootUpsertCacheMut.RLock() + cache, cached := merkleRootUpsertCache[key] + merkleRootUpsertCacheMut.RUnlock() + + var err error + + if !cached { + insert, _ := insertColumns.InsertColumnSet( + merkleRootAllColumns, + merkleRootColumnsWithDefault, + merkleRootColumnsWithoutDefault, + nzDefaults, + ) + + update := updateColumns.UpdateColumnSet( + merkleRootAllColumns, + merkleRootPrimaryKeyColumns, + ) + + if updateOnConflict && len(update) == 0 { + return errors.New("models: unable to upsert merkle_roots, could not build update column list") + } + + ret := strmangle.SetComplement(merkleRootAllColumns, strmangle.SetIntersect(insert, update)) + + conflict := conflictColumns + if len(conflict) == 0 && updateOnConflict && len(update) != 0 { + if len(merkleRootPrimaryKeyColumns) == 0 { + return errors.New("models: unable to upsert merkle_roots, could not build conflict column list") + } + + conflict = make([]string, len(merkleRootPrimaryKeyColumns)) + copy(conflict, merkleRootPrimaryKeyColumns) + } + cache.query = buildUpsertQueryPostgres(dialect, "\"identity_api\".\"merkle_roots\"", updateOnConflict, ret, update, conflict, insert, opts...) + + cache.valueMapping, err = queries.BindMapping(merkleRootType, merkleRootMapping, insert) + if err != nil { + return err + } + if len(ret) != 0 { + cache.retMapping, err = queries.BindMapping(merkleRootType, merkleRootMapping, ret) + if err != nil { + return err + } + } + } + + value := reflect.Indirect(reflect.ValueOf(o)) + vals := queries.ValuesFromMapping(value, cache.valueMapping) + var returns []interface{} + if len(cache.retMapping) != 0 { + returns = queries.PtrsFromMapping(value, cache.retMapping) + } + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, cache.query) + fmt.Fprintln(writer, vals) + } + if len(cache.retMapping) != 0 { + err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) + if errors.Is(err, sql.ErrNoRows) { + err = nil // Postgres doesn't return anything when there's no update + } + } else { + _, err = exec.ExecContext(ctx, cache.query, vals...) + } + if err != nil { + return errors.Wrap(err, "models: unable to upsert merkle_roots") + } + + if !cached { + merkleRootUpsertCacheMut.Lock() + merkleRootUpsertCache[key] = cache + merkleRootUpsertCacheMut.Unlock() + } + + return o.doAfterUpsertHooks(ctx, exec) +} + +// Delete deletes a single MerkleRoot record with an executor. +// Delete will match against the primary key column to find the record to delete. +func (o *MerkleRoot) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if o == nil { + return 0, errors.New("models: no MerkleRoot provided for delete") + } + + if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), merkleRootPrimaryKeyMapping) + sql := "DELETE FROM \"identity_api\".\"merkle_roots\" WHERE \"pool_id\"=$1 AND \"epoch\"=$2" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args...) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete from merkle_roots") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by delete for merkle_roots") + } + + if err := o.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + + return rowsAff, nil +} + +// DeleteAll deletes all matching rows. +func (q merkleRootQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if q.Query == nil { + return 0, errors.New("models: no merkleRootQuery provided for delete all") + } + + queries.SetDelete(q.Query) + + result, err := q.Query.ExecContext(ctx, exec) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merkle_roots") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_roots") + } + + return rowsAff, nil +} + +// DeleteAll deletes all rows in the slice, using an executor. +func (o MerkleRootSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { + if len(o) == 0 { + return 0, nil + } + + if len(merkleRootBeforeDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + var args []interface{} + for _, obj := range o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleRootPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "DELETE FROM \"identity_api\".\"merkle_roots\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merkleRootPrimaryKeyColumns, len(o)) + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, args) + } + result, err := exec.ExecContext(ctx, sql, args...) + if err != nil { + return 0, errors.Wrap(err, "models: unable to delete all from merkleRoot slice") + } + + rowsAff, err := result.RowsAffected() + if err != nil { + return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for merkle_roots") + } + + if len(merkleRootAfterDeleteHooks) != 0 { + for _, obj := range o { + if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { + return 0, err + } + } + } + + return rowsAff, nil +} + +// Reload refetches the object from the database +// using the primary keys with an executor. +func (o *MerkleRoot) Reload(ctx context.Context, exec boil.ContextExecutor) error { + ret, err := FindMerkleRoot(ctx, exec, o.PoolID, o.Epoch) + if err != nil { + return err + } + + *o = *ret + return nil +} + +// ReloadAll refetches every row with matching primary key column values +// and overwrites the original object slice with the newly updated slice. +func (o *MerkleRootSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { + if o == nil || len(*o) == 0 { + return nil + } + + slice := MerkleRootSlice{} + var args []interface{} + for _, obj := range *o { + pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), merkleRootPrimaryKeyMapping) + args = append(args, pkeyArgs...) + } + + sql := "SELECT \"identity_api\".\"merkle_roots\".* FROM \"identity_api\".\"merkle_roots\" WHERE " + + strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, merkleRootPrimaryKeyColumns, len(*o)) + + q := queries.Raw(sql, args...) + + err := q.Bind(ctx, exec, &slice) + if err != nil { + return errors.Wrap(err, "models: unable to reload all in MerkleRootSlice") + } + + *o = slice + + return nil +} + +// MerkleRootExists checks if the MerkleRoot row exists. +func MerkleRootExists(ctx context.Context, exec boil.ContextExecutor, poolID int, epoch int) (bool, error) { + var exists bool + sql := "select exists(select 1 from \"identity_api\".\"merkle_roots\" where \"pool_id\"=$1 AND \"epoch\"=$2 limit 1)" + + if boil.IsDebug(ctx) { + writer := boil.DebugWriterFrom(ctx) + fmt.Fprintln(writer, sql) + fmt.Fprintln(writer, poolID, epoch) + } + row := exec.QueryRowContext(ctx, sql, poolID, epoch) + + err := row.Scan(&exists) + if err != nil { + return false, errors.Wrap(err, "models: unable to check if merkle_roots exists") + } + + return exists, nil +} + +// Exists checks if the MerkleRoot row exists. +func (o *MerkleRoot) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { + return MerkleRootExists(ctx, exec, o.PoolID, o.Epoch) +} diff --git a/models/rewards.go b/models/rewards.go index 006f6a49..3cdb1155 100644 --- a/models/rewards.go +++ b/models/rewards.go @@ -90,27 +90,6 @@ var RewardTableColumns = struct { // Generated where -type whereHelpertypes_Decimal struct{ field string } - -func (w whereHelpertypes_Decimal) EQ(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.EQ, x) -} -func (w whereHelpertypes_Decimal) NEQ(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.NEQ, x) -} -func (w whereHelpertypes_Decimal) LT(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.LT, x) -} -func (w whereHelpertypes_Decimal) LTE(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.LTE, x) -} -func (w whereHelpertypes_Decimal) GT(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.GT, x) -} -func (w whereHelpertypes_Decimal) GTE(x types.Decimal) qm.QueryMod { - return qmhelper.Where(w.field, qmhelper.GTE, x) -} - var RewardWhere = struct { IssuanceWeek whereHelperint VehicleID whereHelperint From dabc42ef2778215963598dd638f96faa5904e06c Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:51:38 -0400 Subject: [PATCH 03/11] feat(merkletree): copy merkle tree package from rewards-api --- pkg/merkletree/merkletree.go | 222 ++++++++++++++++++++++++++++++ pkg/merkletree/merkletree_test.go | 39 ++++++ pkg/merkletree/treefile.go | 193 ++++++++++++++++++++++++++ 3 files changed, 454 insertions(+) create mode 100644 pkg/merkletree/merkletree.go create mode 100644 pkg/merkletree/merkletree_test.go create mode 100644 pkg/merkletree/treefile.go diff --git a/pkg/merkletree/merkletree.go b/pkg/merkletree/merkletree.go new file mode 100644 index 00000000..0833e1c2 --- /dev/null +++ b/pkg/merkletree/merkletree.go @@ -0,0 +1,222 @@ +// Copied from DIMO-Network/rewards-api pkg/merkletree (commit b61e90a); replace +// with module import once published. + +// Package merkletree implements a Merkle tree byte-compatible with OpenZeppelin's +// StandardMerkleTree for the leaf encoding ["address", "uint256", "uint256", +// "address", "uint256"] = (distributor, poolId, week, account, amount), used for +// DIMO reward claims. +// +// Compatibility notes, ported from @openzeppelin/merkle-tree: +// - Leaf hash: keccak256(keccak256(abi.encode(distributor, poolId, week, account, amount))). +// - Leaves are sorted ascending by leaf hash, then stored at the tail of an +// array-backed binary tree of size 2n-1, with sorted leaf i at index 2n-2-i. +// - Parent hash: keccak256(concat(sort(a, b))) (commutative). +// - A proof is the list of sibling hashes on the path from a leaf to the root. +package merkletree + +import ( + "bytes" + "fmt" + "math/big" + "sort" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +var leafABIArguments = func() abi.Arguments { + addressType, err := abi.NewType("address", "", nil) + if err != nil { + panic(fmt.Sprintf("merkletree: creating address ABI type: %v", err)) + } + uint256Type, err := abi.NewType("uint256", "", nil) + if err != nil { + panic(fmt.Sprintf("merkletree: creating uint256 ABI type: %v", err)) + } + return abi.Arguments{ + {Type: addressType}, // distributor + {Type: uint256Type}, // poolId + {Type: uint256Type}, // week + {Type: addressType}, // account + {Type: uint256Type}, // amount + } +}() + +// Leaf is a single claim entry: an account and the amount it can claim. +type Leaf struct { + Account common.Address + Amount *big.Int +} + +// Tree is an OpenZeppelin StandardMerkleTree-compatible Merkle tree over reward +// claim leaves. Construct it with New. +type Tree struct { + distributor common.Address + poolID *big.Int + week *big.Int + // leaves in canonical order, i.e. ascending by leaf hash. The leaf at + // position i sits at tree node index len(nodes)-1-i. + leaves []Leaf + // nodes is the array-backed binary tree of size 2n-1. nodes[0] is the root; + // the children of node i are nodes 2i+1 and 2i+2. + nodes []common.Hash + // nodeIndexByAccount maps an account to the tree node index of its leaf. + nodeIndexByAccount map[common.Address]int +} + +// New builds a Merkle tree for the given distributor, pool, and week over the +// given leaves. It returns an error if leaves is empty, if any account appears +// more than once, or if any amount is nil, zero, or negative. +func New(distributor common.Address, poolID, week *big.Int, leaves []Leaf) (*Tree, error) { + if len(leaves) == 0 { + return nil, fmt.Errorf("expected non-zero number of leaves") + } + if poolID == nil || poolID.Sign() < 0 { + return nil, fmt.Errorf("pool id must be a non-negative integer") + } + if week == nil || week.Sign() < 0 { + return nil, fmt.Errorf("week must be a non-negative integer") + } + + seen := make(map[common.Address]struct{}, len(leaves)) + for _, leaf := range leaves { + if _, ok := seen[leaf.Account]; ok { + return nil, fmt.Errorf("duplicate account %s", leaf.Account.Hex()) + } + seen[leaf.Account] = struct{}{} + if leaf.Amount == nil { + return nil, fmt.Errorf("nil amount for account %s", leaf.Account.Hex()) + } + if leaf.Amount.Sign() <= 0 { + return nil, fmt.Errorf("amount for account %s must be positive, got %s", leaf.Account.Hex(), leaf.Amount) + } + if leaf.Amount.BitLen() > 256 { + return nil, fmt.Errorf("amount for account %s overflows uint256", leaf.Account.Hex()) + } + } + + type hashedLeaf struct { + leaf Leaf + hash common.Hash + } + hashed := make([]hashedLeaf, len(leaves)) + for i, leaf := range leaves { + hash, err := leafHash(distributor, poolID, week, leaf) + if err != nil { + return nil, fmt.Errorf("hashing leaf for account %s: %w", leaf.Account.Hex(), err) + } + hashed[i] = hashedLeaf{leaf: leaf, hash: hash} + } + + // OZ sorts leaves ascending by hash before building the tree. Leaf hashes + // are collision-free in practice, so the order is total and sort.Slice + // suffices; stability would be meaningless here. + sort.Slice(hashed, func(i, j int) bool { + return bytes.Compare(hashed[i].hash[:], hashed[j].hash[:]) < 0 + }) + + n := len(hashed) + nodes := make([]common.Hash, 2*n-1) + sorted := make([]Leaf, n) + nodeIndexByAccount := make(map[common.Address]int, n) + for i, hl := range hashed { + nodeIndex := len(nodes) - 1 - i + nodes[nodeIndex] = hl.hash + sorted[i] = hl.leaf + nodeIndexByAccount[hl.leaf.Account] = nodeIndex + } + for i := len(nodes) - 1 - n; i >= 0; i-- { + nodes[i] = hashPair(nodes[2*i+1], nodes[2*i+2]) + } + + return &Tree{ + distributor: distributor, + poolID: new(big.Int).Set(poolID), + week: new(big.Int).Set(week), + leaves: sorted, + nodes: nodes, + nodeIndexByAccount: nodeIndexByAccount, + }, nil +} + +// Root returns the Merkle root of the tree. +func (t *Tree) Root() common.Hash { + return t.nodes[0] +} + +// Proof returns the Merkle proof for the leaf belonging to the given account. +// It returns an error if the account is not in the tree. +func (t *Tree) Proof(account common.Address) ([]common.Hash, error) { + index, ok := t.nodeIndexByAccount[account] + if !ok { + return nil, fmt.Errorf("account %s is not in the tree", account.Hex()) + } + proof := []common.Hash{} + for index > 0 { + proof = append(proof, t.nodes[siblingIndex(index)]) + index = (index - 1) / 2 + } + return proof, nil +} + +// Leaves returns the leaves in canonical order, i.e. ascending by leaf hash. +func (t *Tree) Leaves() []Leaf { + leaves := make([]Leaf, len(t.leaves)) + copy(leaves, t.leaves) + return leaves +} + +// MarshalJSON encodes the tree in the dimo-merkle-v1 file format. All numeric +// values are encoded as decimal strings, never as JSON numbers, and addresses +// are EIP-55 checksummed. +func (t *Tree) MarshalJSON() ([]byte, error) { + file := TreeFile{ + Format: TreeFileFormatV1, + Distributor: t.distributor, + PoolID: new(big.Int).Set(t.poolID), + Week: new(big.Int).Set(t.week), + Root: t.Root(), + Leaves: make([]TreeFileLeaf, len(t.leaves)), + } + for i, leaf := range t.leaves { + proof, err := t.Proof(leaf.Account) + if err != nil { + return nil, fmt.Errorf("computing proof for account %s: %w", leaf.Account.Hex(), err) + } + file.Leaves[i] = TreeFileLeaf{ + Account: leaf.Account, + Amount: new(big.Int).Set(leaf.Amount), + Proof: proof, + } + } + return file.MarshalJSON() +} + +// leafHash computes the OZ standard leaf hash: the keccak256 of the keccak256 +// of the standard ABI encoding of (distributor, poolId, week, account, amount). +func leafHash(distributor common.Address, poolID, week *big.Int, leaf Leaf) (common.Hash, error) { + encoded, err := leafABIArguments.Pack(distributor, poolID, week, leaf.Account, leaf.Amount) + if err != nil { + return common.Hash{}, fmt.Errorf("abi-encoding leaf: %w", err) + } + return crypto.Keccak256Hash(crypto.Keccak256(encoded)), nil +} + +// hashPair computes the OZ standard node hash: the keccak256 of the +// concatenation of a and b with the smaller of the two first. +func hashPair(a, b common.Hash) common.Hash { + if bytes.Compare(a[:], b[:]) > 0 { + a, b = b, a + } + return crypto.Keccak256Hash(a[:], b[:]) +} + +// siblingIndex returns the index of the sibling of node i in the array-backed +// tree. The root (i = 0) has no sibling. +func siblingIndex(i int) int { + if i%2 == 1 { + return i + 1 + } + return i - 1 +} diff --git a/pkg/merkletree/merkletree_test.go b/pkg/merkletree/merkletree_test.go new file mode 100644 index 00000000..cee36320 --- /dev/null +++ b/pkg/merkletree/merkletree_test.go @@ -0,0 +1,39 @@ +package merkletree + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// TestTreeFileRoundTrip is a smoke test for the copied package: build a 3-leaf +// tree, marshal it to the dimo-merkle-v1 format, parse it back, and check that +// VerifyRoot passes. Then tamper with a leaf and check that VerifyRoot fails. +func TestTreeFileRoundTrip(t *testing.T) { + distributor := common.HexToAddress("0x1111111111111111111111111111111111111111") + leaves := []Leaf{ + {Account: common.HexToAddress("0x2222222222222222222222222222222222222222"), Amount: big.NewInt(100)}, + {Account: common.HexToAddress("0x3333333333333333333333333333333333333333"), Amount: big.NewInt(200)}, + {Account: common.HexToAddress("0x4444444444444444444444444444444444444444"), Amount: big.NewInt(300)}, + } + + tree, err := New(distributor, big.NewInt(0), big.NewInt(214), leaves) + require.NoError(t, err) + + data, err := tree.MarshalJSON() + require.NoError(t, err) + + file, err := UnmarshalTreeFile(data) + require.NoError(t, err) + + assert.Equal(t, tree.Root(), file.Root) + assert.Len(t, file.Leaves, 3) + require.NoError(t, file.VerifyRoot()) + + // Tampering with an amount must break root verification. + file.Leaves[0].Amount = new(big.Int).Add(file.Leaves[0].Amount, big.NewInt(1)) + assert.Error(t, file.VerifyRoot()) +} diff --git a/pkg/merkletree/treefile.go b/pkg/merkletree/treefile.go new file mode 100644 index 00000000..0d335927 --- /dev/null +++ b/pkg/merkletree/treefile.go @@ -0,0 +1,193 @@ +// Copied from DIMO-Network/rewards-api pkg/merkletree (commit b61e90a); replace +// with module import once published. + +package merkletree + +import ( + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +// TreeFileFormatV1 is the format identifier for version 1 of the DIMO Merkle +// tree file format. +const TreeFileFormatV1 = "dimo-merkle-v1" + +// TreeFile is the parsed form of a dimo-merkle-v1 tree file. It carries +// everything a consumer needs to verify the root and serve proofs. +type TreeFile struct { + Format string + Distributor common.Address + PoolID *big.Int + Week *big.Int + Root common.Hash + Leaves []TreeFileLeaf +} + +// TreeFileLeaf is a single claim entry in a tree file, together with its +// Merkle proof. +type TreeFileLeaf struct { + Account common.Address + Amount *big.Int + Proof []common.Hash +} + +type treeFileJSON struct { + Format string `json:"format"` + Distributor string `json:"distributor"` + PoolID string `json:"poolId"` + Week string `json:"week"` + Root string `json:"root"` + Leaves []treeFileLeafJSON `json:"leaves"` +} + +type treeFileLeafJSON struct { + Account string `json:"account"` + Amount string `json:"amount"` + Proof []string `json:"proof"` +} + +// MarshalJSON encodes the tree file in the dimo-merkle-v1 format with all +// numeric values as decimal strings and addresses EIP-55 checksummed. +func (f *TreeFile) MarshalJSON() ([]byte, error) { + out := treeFileJSON{ + Format: f.Format, + Distributor: f.Distributor.Hex(), + PoolID: f.PoolID.String(), + Week: f.Week.String(), + Root: f.Root.Hex(), + Leaves: make([]treeFileLeafJSON, len(f.Leaves)), + } + for i, leaf := range f.Leaves { + proof := make([]string, len(leaf.Proof)) + for j, p := range leaf.Proof { + proof[j] = p.Hex() + } + out.Leaves[i] = treeFileLeafJSON{ + Account: leaf.Account.Hex(), + Amount: leaf.Amount.String(), + Proof: proof, + } + } + return json.Marshal(out) +} + +// UnmarshalTreeFile parses and validates a dimo-merkle-v1 tree file. It does +// not verify the root; call VerifyRoot for that. +func UnmarshalTreeFile(data []byte) (*TreeFile, error) { + var raw treeFileJSON + if err := json.Unmarshal(data, &raw); err != nil { + return nil, fmt.Errorf("parsing tree file: %w", err) + } + if raw.Format != TreeFileFormatV1 { + return nil, fmt.Errorf("unknown tree file format %q, expected %q", raw.Format, TreeFileFormatV1) + } + + distributor, err := parseAddress(raw.Distributor) + if err != nil { + return nil, fmt.Errorf("parsing distributor: %w", err) + } + poolID, err := parseDecimal(raw.PoolID) + if err != nil { + return nil, fmt.Errorf("parsing pool id: %w", err) + } + if poolID.Sign() < 0 { + return nil, fmt.Errorf("pool id must be non-negative, got %s", poolID) + } + week, err := parseDecimal(raw.Week) + if err != nil { + return nil, fmt.Errorf("parsing week: %w", err) + } + if week.Sign() < 0 { + return nil, fmt.Errorf("week must be non-negative, got %s", week) + } + root, err := parseHash(raw.Root) + if err != nil { + return nil, fmt.Errorf("parsing root: %w", err) + } + + file := &TreeFile{ + Format: raw.Format, + Distributor: distributor, + PoolID: poolID, + Week: week, + Root: root, + Leaves: make([]TreeFileLeaf, len(raw.Leaves)), + } + for i, rawLeaf := range raw.Leaves { + account, err := parseAddress(rawLeaf.Account) + if err != nil { + return nil, fmt.Errorf("parsing account in leaf %d: %w", i, err) + } + amount, err := parseDecimal(rawLeaf.Amount) + if err != nil { + return nil, fmt.Errorf("parsing amount in leaf %d: %w", i, err) + } + if amount.Sign() <= 0 { + return nil, fmt.Errorf("amount in leaf %d must be positive, got %s", i, amount) + } + proof := make([]common.Hash, len(rawLeaf.Proof)) + for j, p := range rawLeaf.Proof { + proof[j], err = parseHash(p) + if err != nil { + return nil, fmt.Errorf("parsing proof element %d in leaf %d: %w", j, i, err) + } + } + file.Leaves[i] = TreeFileLeaf{Account: account, Amount: amount, Proof: proof} + } + return file, nil +} + +// VerifyRoot rebuilds the Merkle tree from the leaves in the file and returns +// an error if the recomputed root does not match the stored root. +func (f *TreeFile) VerifyRoot() error { + leaves := make([]Leaf, len(f.Leaves)) + for i, leaf := range f.Leaves { + leaves[i] = Leaf{Account: leaf.Account, Amount: leaf.Amount} + } + tree, err := New(f.Distributor, f.PoolID, f.Week, leaves) + if err != nil { + return fmt.Errorf("rebuilding tree from leaves: %w", err) + } + if root := tree.Root(); root != f.Root { + return fmt.Errorf("recomputed root %s does not match stored root %s", root.Hex(), f.Root.Hex()) + } + return nil +} + +func parseAddress(s string) (common.Address, error) { + if !common.IsHexAddress(s) { + return common.Address{}, fmt.Errorf("invalid address %q", s) + } + return common.HexToAddress(s), nil +} + +func parseDecimal(s string) (*big.Int, error) { + v, ok := new(big.Int).SetString(s, 10) + if !ok { + return nil, fmt.Errorf("invalid decimal string %q", s) + } + return v, nil +} + +func parseHash(s string) (common.Hash, error) { + b, err := hexDecode32(s) + if err != nil { + return common.Hash{}, err + } + return common.BytesToHash(b), nil +} + +func hexDecode32(s string) ([]byte, error) { + if len(s) != 66 || s[:2] != "0x" { + return nil, fmt.Errorf("expected 0x-prefixed 64-character hex string, got %q", s) + } + b, err := hex.DecodeString(s[2:]) + if err != nil { + return nil, fmt.Errorf("decoding hex string %q: %w", s, err) + } + return b, nil +} From c3b340a909434a2f97bd31fc467e1dfa6ed7fd70 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:51:38 -0400 Subject: [PATCH 04/11] feat(consumer): index MerkleDistributor contract events --- internal/dbtypes/int.go | 8 + .../services/contracts_events_consumer.go | 24 +- internal/services/merkle/events.go | 63 ++++ internal/services/merkle/fetcher.go | 80 +++++ internal/services/merkle/handler.go | 308 ++++++++++++++++ internal/services/merkle/handler_test.go | 340 ++++++++++++++++++ internal/services/merkle_consumer_test.go | 57 +++ 7 files changed, 874 insertions(+), 6 deletions(-) create mode 100644 internal/services/merkle/events.go create mode 100644 internal/services/merkle/fetcher.go create mode 100644 internal/services/merkle/handler.go create mode 100644 internal/services/merkle/handler_test.go create mode 100644 internal/services/merkle_consumer_test.go diff --git a/internal/dbtypes/int.go b/internal/dbtypes/int.go index 477845ed..614092f0 100644 --- a/internal/dbtypes/int.go +++ b/internal/dbtypes/int.go @@ -10,3 +10,11 @@ import ( func IntToDecimal(x *big.Int) types.Decimal { return types.NewDecimal(new(decimal.Big).SetBigMantScale(x, 0)) } + +// NullIntToDecimal converts a *big.Int into a NullDecimal, mapping nil to null. +func NullIntToDecimal(x *big.Int) types.NullDecimal { + if x == nil { + return types.NewNullDecimal(nil) + } + return types.NewNullDecimal(new(decimal.Big).SetBigMantScale(x, 0)) +} diff --git a/internal/services/contracts_events_consumer.go b/internal/services/contracts_events_consumer.go index 0bb86f99..10e01719 100644 --- a/internal/services/contracts_events_consumer.go +++ b/internal/services/contracts_events_consumer.go @@ -14,6 +14,7 @@ import ( "github.com/DIMO-Network/identity-api/internal/dbtypes" "github.com/DIMO-Network/identity-api/internal/helpers" "github.com/DIMO-Network/identity-api/internal/services/connection" + "github.com/DIMO-Network/identity-api/internal/services/merkle" cmodels "github.com/DIMO-Network/identity-api/internal/services/models" "github.com/DIMO-Network/identity-api/internal/services/staking" "github.com/DIMO-Network/identity-api/internal/services/storagenode" @@ -35,6 +36,7 @@ type ContractsEventsConsumer struct { stakingHandler *staking.Handler connsHandler *connection.Handler storageNodeHandler *storagenode.Handler + merkleHandler *merkle.Handler } type EventName string @@ -104,18 +106,25 @@ func (r EventName) String() string { const contractEventCEType = "zone.dimo.contract.event" func NewContractsEventsConsumer(dbs db.Store, log *zerolog.Logger, settings *config.Settings) *ContractsEventsConsumer { + httpClient := &http.Client{ + Timeout: 10 * time.Second, + } + return &ContractsEventsConsumer{ - dbs: dbs, - log: log, - settings: settings, - httpClient: &http.Client{ - Timeout: 10 * time.Second, - }, + dbs: dbs, + log: log, + settings: settings, + httpClient: httpClient, stakingHandler: &staking.Handler{ DBS: dbs, }, connsHandler: &connection.Handler{DBS: dbs, Logger: log}, storageNodeHandler: &storagenode.Handler{DBS: dbs, Logger: log}, + merkleHandler: &merkle.Handler{ + DBS: dbs, + Logger: log, + Fetcher: merkle.NewHTTPTreeFetcher(httpClient, settings.MerkleTreeAllowedHost), + }, } } @@ -142,6 +151,7 @@ func (c *ContractsEventsConsumer) Process(ctx context.Context, event *cloudevent manufacturerAddr := common.HexToAddress(c.settings.ManufacturerNFTAddr) storageNodeAddr := common.HexToAddress(c.settings.StorageNodeAddr) templateAddr := common.HexToAddress(c.settings.TemplateAddr) + merkleDistributorAddr := common.HexToAddress(c.settings.MerkleDistributorAddr) var data cmodels.ContractEventData if err := json.Unmarshal(event.Data, &data); err != nil { @@ -265,6 +275,8 @@ func (c *ContractsEventsConsumer) Process(ctx context.Context, event *cloudevent return c.connsHandler.Handle(ctx, &data) case storageNodeAddr: return c.storageNodeHandler.Handle(ctx, &data) + case merkleDistributorAddr: + return c.merkleHandler.Handle(ctx, &data) } c.log.Debug().Str("event", data.EventName).Msg("Handler not provided for event.") diff --git a/internal/services/merkle/events.go b/internal/services/merkle/events.go new file mode 100644 index 00000000..b175448d --- /dev/null +++ b/internal/services/merkle/events.go @@ -0,0 +1,63 @@ +package merkle + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" +) + +// Event names emitted by the MerkleDistributor contract. +const ( + PoolCreated = "PoolCreated" + RootSet = "RootSet" + Claimed = "Claimed" + Funded = "Funded" + Swept = "Swept" + WeeklyLimitSet = "WeeklyLimitSet" +) + +// PoolCreatedData represents PoolCreated(uint256 indexed poolId, address indexed token, address indexed admin, uint256 weeklyLimit). +type PoolCreatedData struct { + PoolId *big.Int `json:"poolId"` + Token common.Address `json:"token"` + Admin common.Address `json:"admin"` + WeeklyLimit *big.Int `json:"weeklyLimit"` +} + +// RootSetData represents RootSet(uint256 indexed poolId, uint256 indexed week, bytes32 root, uint256 allocation, string proofsURI). +type RootSetData struct { + PoolId *big.Int `json:"poolId"` + Week *big.Int `json:"week"` + Root [32]byte `json:"root"` + Allocation *big.Int `json:"allocation"` + ProofsURI string `json:"proofsURI"` +} + +// ClaimedData represents Claimed(uint256 indexed poolId, uint256 indexed week, address indexed account, uint256 amount). +type ClaimedData struct { + PoolId *big.Int `json:"poolId"` + Week *big.Int `json:"week"` + Account common.Address `json:"account"` + Amount *big.Int `json:"amount"` +} + +// FundedData represents Funded(uint256 indexed poolId, address indexed from, uint256 amount). +type FundedData struct { + PoolId *big.Int `json:"poolId"` + From common.Address `json:"from"` + Amount *big.Int `json:"amount"` +} + +// SweptData represents Swept(uint256 indexed poolId, address indexed to, uint256 amount, uint256 newBalance). +type SweptData struct { + PoolId *big.Int `json:"poolId"` + To common.Address `json:"to"` + Amount *big.Int `json:"amount"` + NewBalance *big.Int `json:"newBalance"` +} + +// WeeklyLimitSetData represents WeeklyLimitSet(uint256 indexed poolId, uint256 limit). +type WeeklyLimitSetData struct { + PoolId *big.Int `json:"poolId"` + Limit *big.Int `json:"limit"` +} diff --git a/internal/services/merkle/fetcher.go b/internal/services/merkle/fetcher.go new file mode 100644 index 00000000..6f3036b7 --- /dev/null +++ b/internal/services/merkle/fetcher.go @@ -0,0 +1,80 @@ +package merkle + +import ( + "context" + "fmt" + "io" + "net/http" + "net/url" + "slices" + "strings" +) + +// maxTreeFileSize is the maximum number of bytes we are willing to read from a +// Merkle tree file referenced by a RootSet event. +const maxTreeFileSize = 50 * 1024 * 1024 + +// TreeFetcher retrieves the Merkle tree file referenced by a RootSet event's +// proofsURI. +type TreeFetcher interface { + Fetch(ctx context.Context, uri string) ([]byte, error) +} + +// HTTPTreeFetcher fetches tree files over HTTPS. Only hosts in AllowedHosts +// are permitted, and responses are capped at maxTreeFileSize bytes. +type HTTPTreeFetcher struct { + Client *http.Client + AllowedHosts []string +} + +// NewHTTPTreeFetcher creates an HTTPTreeFetcher from a comma-separated list of +// allowed hosts. +func NewHTTPTreeFetcher(client *http.Client, allowedHosts string) *HTTPTreeFetcher { + var hosts []string + for h := range strings.SplitSeq(allowedHosts, ",") { + if h = strings.TrimSpace(h); h != "" { + hosts = append(hosts, strings.ToLower(h)) + } + } + return &HTTPTreeFetcher{Client: client, AllowedHosts: hosts} +} + +// Fetch retrieves the file at the given URI, enforcing the host allowlist and +// the response size cap. +func (f *HTTPTreeFetcher) Fetch(ctx context.Context, uri string) ([]byte, error) { + u, err := url.Parse(uri) + if err != nil { + return nil, fmt.Errorf("parsing proofs URI %q: %w", uri, err) + } + if u.Scheme != "https" { + return nil, fmt.Errorf("proofs URI %q does not use https", uri) + } + if !slices.Contains(f.AllowedHosts, strings.ToLower(u.Host)) { + return nil, fmt.Errorf("proofs URI host %q is not in the allowed list", u.Host) + } + + req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil) + if err != nil { + return nil, fmt.Errorf("creating request for %q: %w", uri, err) + } + + resp, err := f.Client.Do(req) + if err != nil { + return nil, fmt.Errorf("fetching %q: %w", uri, err) + } + defer resp.Body.Close() //nolint:errcheck + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("fetching %q: status code %d", uri, resp.StatusCode) + } + + body, err := io.ReadAll(io.LimitReader(resp.Body, maxTreeFileSize+1)) + if err != nil { + return nil, fmt.Errorf("reading body of %q: %w", uri, err) + } + if len(body) > maxTreeFileSize { + return nil, fmt.Errorf("tree file at %q exceeds the size limit of %d bytes", uri, maxTreeFileSize) + } + + return body, nil +} diff --git a/internal/services/merkle/handler.go b/internal/services/merkle/handler.go new file mode 100644 index 00000000..cc8b682f --- /dev/null +++ b/internal/services/merkle/handler.go @@ -0,0 +1,308 @@ +// Package merkle indexes events emitted by the MerkleDistributor contract: +// reward pools, weekly Merkle roots, and individual claims. +package merkle + +import ( + "context" + "database/sql" + "errors" + "fmt" + + "github.com/DIMO-Network/identity-api/internal/dbtypes" + "github.com/DIMO-Network/identity-api/internal/helpers" + cmodels "github.com/DIMO-Network/identity-api/internal/services/models" + "github.com/DIMO-Network/identity-api/models" + "github.com/DIMO-Network/identity-api/pkg/merkletree" + "github.com/DIMO-Network/shared/pkg/db" + "github.com/aarondl/null/v8" + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/aarondl/sqlboiler/v4/queries/qm" + "github.com/ethereum/go-ethereum/common" + "github.com/goccy/go-json" + "github.com/rs/zerolog" +) + +// Handler processes MerkleDistributor contract events. +type Handler struct { + DBS db.Store + Logger *zerolog.Logger + Fetcher TreeFetcher +} + +// Handle routes a MerkleDistributor contract event to the matching handler. +func (h *Handler) Handle(ctx context.Context, event *cmodels.ContractEventData) error { + switch event.EventName { + case PoolCreated: + var args PoolCreatedData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handlePoolCreated(ctx, event, &args) + case RootSet: + var args RootSetData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handleRootSet(ctx, event, &args) + case Claimed: + var args ClaimedData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handleClaimed(ctx, event, &args) + case Funded: + var args FundedData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handleFunded(ctx, event, &args) + case Swept: + var args SweptData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handleSwept(ctx, event, &args) + case WeeklyLimitSet: + var args WeeklyLimitSetData + if err := json.Unmarshal(event.Arguments, &args); err != nil { + return err + } + return h.handleWeeklyLimitSet(ctx, event, &args) + } + + return nil +} + +func (h *Handler) handlePoolCreated(ctx context.Context, e *cmodels.ContractEventData, args *PoolCreatedData) error { + pool := models.MerklePool{ + PoolID: int(args.PoolId.Int64()), + Token: args.Token.Bytes(), + Admin: args.Admin.Bytes(), + WeeklyLimit: dbtypes.NullIntToDecimal(args.WeeklyLimit), + CreatedAt: e.Block.Time, + } + + cols := models.MerklePoolColumns + + // Don't touch the balance on conflict. + return pool.Upsert(ctx, h.DBS.DBS().Writer, true, + []string{cols.PoolID}, + boil.Whitelist(cols.Token, cols.Admin, cols.WeeklyLimit, cols.CreatedAt), + boil.Infer(), + ) +} + +func (h *Handler) handleWeeklyLimitSet(ctx context.Context, e *cmodels.ContractEventData, args *WeeklyLimitSetData) error { + pool := models.MerklePool{ + PoolID: int(args.PoolId.Int64()), + WeeklyLimit: dbtypes.NullIntToDecimal(args.Limit), + } + + rowsAff, err := pool.Update(ctx, h.DBS.DBS().Writer, boil.Whitelist(models.MerklePoolColumns.WeeklyLimit)) + if err != nil { + return err + } + if rowsAff == 0 { + return fmt.Errorf("WeeklyLimitSet for unknown pool %d", pool.PoolID) + } + + return nil +} + +func (h *Handler) handleFunded(ctx context.Context, e *cmodels.ContractEventData, args *FundedData) error { + res, err := h.DBS.DBS().Writer.ExecContext(ctx, + fmt.Sprintf("UPDATE %s SET balance = balance + $1 WHERE pool_id = $2", helpers.WithSchema(models.TableNames.MerklePools)), + dbtypes.IntToDecimal(args.Amount), int(args.PoolId.Int64()), + ) + if err != nil { + return err + } + rowsAff, err := res.RowsAffected() + if err != nil { + return err + } + if rowsAff == 0 { + return fmt.Errorf("Funded for unknown pool %d", args.PoolId) + } + + return nil +} + +func (h *Handler) handleSwept(ctx context.Context, e *cmodels.ContractEventData, args *SweptData) error { + pool := models.MerklePool{ + PoolID: int(args.PoolId.Int64()), + Balance: dbtypes.IntToDecimal(args.NewBalance), + } + + rowsAff, err := pool.Update(ctx, h.DBS.DBS().Writer, boil.Whitelist(models.MerklePoolColumns.Balance)) + if err != nil { + return err + } + if rowsAff == 0 { + return fmt.Errorf("Swept for unknown pool %d", pool.PoolID) + } + + return nil +} + +func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventData, args *RootSetData) error { + logger := h.Logger.With(). + Str("EventName", RootSet). + Str("poolId", args.PoolId.String()). + Str("week", args.Week.String()). + Logger() + + data, err := h.Fetcher.Fetch(ctx, args.ProofsURI) + if err != nil { + logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Failed to fetch Merkle tree file.") + return fmt.Errorf("fetching tree file: %w", err) + } + + file, err := merkletree.UnmarshalTreeFile(data) + if err != nil { + logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Failed to parse Merkle tree file.") + return fmt.Errorf("parsing tree file: %w", err) + } + + if err := file.VerifyRoot(); err != nil { + logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Merkle tree file failed root verification.") + return fmt.Errorf("verifying tree file root: %w", err) + } + + if file.Root != common.Hash(args.Root) { + err := fmt.Errorf("tree file root %s does not match event root %s", file.Root, common.Hash(args.Root)) + logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Merkle tree file root mismatch.") + return err + } + + if file.PoolID.Cmp(args.PoolId) != 0 || file.Week.Cmp(args.Week) != 0 { + err := fmt.Errorf("tree file is for pool %s, week %s; event is for pool %s, week %s", file.PoolID, file.Week, args.PoolId, args.Week) + logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Merkle tree file pool or week mismatch.") + return err + } + + if file.Distributor != e.Contract { + logger.Warn().Msgf("Tree file distributor %s does not match emitting contract %s.", file.Distributor, e.Contract) + } + + tx, err := h.DBS.DBS().Writer.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() //nolint:errcheck + + root := models.MerkleRoot{ + PoolID: int(args.PoolId.Int64()), + Epoch: int(args.Week.Int64()), + Root: args.Root[:], + Allocation: dbtypes.IntToDecimal(args.Allocation), + RecipientCount: len(file.Leaves), + ProofsURI: args.ProofsURI, + SetAt: e.Block.Time, + } + + rootCols := models.MerkleRootColumns + + // Preserve total_claimed and claim_count if the root is set again. + err = root.Upsert(ctx, tx, true, + []string{rootCols.PoolID, rootCols.Epoch}, + boil.Whitelist(rootCols.Root, rootCols.Allocation, rootCols.RecipientCount, rootCols.ProofsURI, rootCols.SetAt), + boil.Infer(), + ) + if err != nil { + return fmt.Errorf("upserting Merkle root: %w", err) + } + + claimCols := models.MerkleClaimColumns + + for _, leaf := range file.Leaves { + proof := make([]string, len(leaf.Proof)) + for i, p := range leaf.Proof { + proof[i] = p.Hex() + } + proofJSON, err := json.Marshal(proof) + if err != nil { + return fmt.Errorf("marshaling proof for account %s: %w", leaf.Account, err) + } + + claim := models.MerkleClaim{ + PoolID: root.PoolID, + Epoch: root.Epoch, + Account: leaf.Account.Bytes(), + Amount: dbtypes.IntToDecimal(leaf.Amount), + Proof: proofJSON, + } + + // Preserve claimed_at and claim_tx if the leaf was already claimed. + err = claim.Upsert(ctx, tx, true, + []string{claimCols.PoolID, claimCols.Epoch, claimCols.Account}, + boil.Whitelist(claimCols.Amount, claimCols.Proof), + boil.Infer(), + ) + if err != nil { + return fmt.Errorf("upserting Merkle claim for account %s: %w", leaf.Account, err) + } + } + + if err := tx.Commit(); err != nil { + return err + } + + logger.Info().Int("recipientCount", len(file.Leaves)).Msg("Merkle root set.") + + return nil +} + +func (h *Handler) handleClaimed(ctx context.Context, e *cmodels.ContractEventData, args *ClaimedData) error { + poolID := int(args.PoolId.Int64()) + epoch := int(args.Week.Int64()) + + tx, err := h.DBS.DBS().Writer.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() //nolint:errcheck + + claim, err := models.MerkleClaims( + models.MerkleClaimWhere.PoolID.EQ(poolID), + models.MerkleClaimWhere.Epoch.EQ(epoch), + models.MerkleClaimWhere.Account.EQ(args.Account.Bytes()), + qm.For("UPDATE"), + ).One(ctx, tx) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return fmt.Errorf("Claimed for unknown leaf: pool %d, epoch %d, account %s", poolID, epoch, args.Account) + } + return err + } + + if claim.ClaimedAt.Valid { + // Already processed; don't double-count. + return nil + } + + claim.ClaimedAt = null.TimeFrom(e.Block.Time) + claim.ClaimTX = null.BytesFrom(e.TransactionHash.Bytes()) + + if _, err := claim.Update(ctx, tx, boil.Whitelist(models.MerkleClaimColumns.ClaimedAt, models.MerkleClaimColumns.ClaimTX)); err != nil { + return fmt.Errorf("updating Merkle claim: %w", err) + } + + amount := dbtypes.IntToDecimal(args.Amount) + + if _, err := tx.ExecContext(ctx, + fmt.Sprintf("UPDATE %s SET total_claimed = total_claimed + $1, claim_count = claim_count + 1 WHERE pool_id = $2 AND epoch = $3", helpers.WithSchema(models.TableNames.MerkleRoots)), + amount, poolID, epoch, + ); err != nil { + return fmt.Errorf("updating Merkle root claim totals: %w", err) + } + + if _, err := tx.ExecContext(ctx, + fmt.Sprintf("UPDATE %s SET balance = balance - $1 WHERE pool_id = $2", helpers.WithSchema(models.TableNames.MerklePools)), + amount, poolID, + ); err != nil { + return fmt.Errorf("updating Merkle pool balance: %w", err) + } + + return tx.Commit() +} diff --git a/internal/services/merkle/handler_test.go b/internal/services/merkle/handler_test.go new file mode 100644 index 00000000..4ab2bdb6 --- /dev/null +++ b/internal/services/merkle/handler_test.go @@ -0,0 +1,340 @@ +package merkle + +import ( + "context" + "fmt" + "math/big" + "os" + "testing" + "time" + + "github.com/DIMO-Network/identity-api/internal/helpers" + cmodels "github.com/DIMO-Network/identity-api/internal/services/models" + "github.com/DIMO-Network/identity-api/models" + "github.com/DIMO-Network/identity-api/pkg/merkletree" + "github.com/ethereum/go-ethereum/common" + "github.com/goccy/go-json" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const migrationsDirRelPath = "../../../migrations" + +var ( + distributorAddr = common.HexToAddress("0x4f5e9320b1c7cB3DE5ebDD760aD67375B66cF8a4") + tokenAddr = common.HexToAddress("0xE261D618a959aFfFd53168Cd07D12E37B26761db") + adminAddr = common.HexToAddress("0xaba3A41bd932244Dd08186e4c19F1a7E48cbcDf4") + account1 = common.HexToAddress("0x2222222222222222222222222222222222222222") + account2 = common.HexToAddress("0x3333333333333333333333333333333333333333") + account3 = common.HexToAddress("0x4444444444444444444444444444444444444444") +) + +type fakeFetcher struct { + data map[string][]byte +} + +func (f *fakeFetcher) Fetch(_ context.Context, uri string) ([]byte, error) { + d, ok := f.data[uri] + if !ok { + return nil, fmt.Errorf("no data for uri %q", uri) + } + return d, nil +} + +func eventData(t *testing.T, name string, blockTime time.Time, args any) *cmodels.ContractEventData { + t.Helper() + + argBytes, err := json.Marshal(args) + require.NoError(t, err) + + return &cmodels.ContractEventData{ + EventName: name, + Contract: distributorAddr, + TransactionHash: common.HexToHash("0x811a85e24d0129a2018c9a6668652db63d73bc6d1c76f21b07da2162c6bfea7d"), + Block: cmodels.Block{Time: blockTime}, + Arguments: argBytes, + } +} + +func newTestHandler(t *testing.T, fetcher TreeFetcher) (*Handler, context.Context) { + t.Helper() + ctx := context.Background() + + logger := zerolog.New(os.Stdout).With().Timestamp().Str("app", helpers.DBSettings.Name).Logger() + pdb, _ := helpers.StartContainerDatabase(ctx, t, migrationsDirRelPath) + + return &Handler{DBS: pdb, Logger: &logger, Fetcher: fetcher}, ctx +} + +func createPool(t *testing.T, ctx context.Context, h *Handler, poolID int64) { + t.Helper() + + err := h.Handle(ctx, eventData(t, PoolCreated, time.Now(), PoolCreatedData{ + PoolId: big.NewInt(poolID), + Token: tokenAddr, + Admin: adminAddr, + WeeklyLimit: big.NewInt(5000), + })) + require.NoError(t, err) +} + +func buildTree(t *testing.T, poolID, week int64) (*merkletree.Tree, []byte) { + t.Helper() + + tree, err := merkletree.New(distributorAddr, big.NewInt(poolID), big.NewInt(week), []merkletree.Leaf{ + {Account: account1, Amount: big.NewInt(100)}, + {Account: account2, Amount: big.NewInt(200)}, + {Account: account3, Amount: big.NewInt(300)}, + }) + require.NoError(t, err) + + data, err := tree.MarshalJSON() + require.NoError(t, err) + + return tree, data +} + +func TestHandlePoolCreatedAndBalanceEvents(t *testing.T) { + h, ctx := newTestHandler(t, &fakeFetcher{}) + + createdAt := time.Now() + + err := h.Handle(ctx, eventData(t, PoolCreated, createdAt, PoolCreatedData{ + PoolId: big.NewInt(0), + Token: tokenAddr, + Admin: adminAddr, + WeeklyLimit: big.NewInt(5000), + })) + require.NoError(t, err) + + pool, err := models.FindMerklePool(ctx, h.DBS.DBS().Reader, 0) + require.NoError(t, err) + assert.Equal(t, tokenAddr.Bytes(), pool.Token) + assert.Equal(t, adminAddr.Bytes(), pool.Admin) + assert.Equal(t, "5000", pool.WeeklyLimit.Big.String()) + assert.Equal(t, "0", pool.Balance.Big.String()) + assert.WithinDuration(t, createdAt, pool.CreatedAt, time.Second) + + // WeeklyLimitSet updates the limit. + err = h.Handle(ctx, eventData(t, WeeklyLimitSet, time.Now(), WeeklyLimitSetData{ + PoolId: big.NewInt(0), + Limit: big.NewInt(7000), + })) + require.NoError(t, err) + + // Funded adds to the balance. + err = h.Handle(ctx, eventData(t, Funded, time.Now(), FundedData{ + PoolId: big.NewInt(0), + From: adminAddr, + Amount: big.NewInt(1000), + })) + require.NoError(t, err) + + require.NoError(t, pool.Reload(ctx, h.DBS.DBS().Reader)) + assert.Equal(t, "7000", pool.WeeklyLimit.Big.String()) + assert.Equal(t, "1000", pool.Balance.Big.String()) + + // Swept sets the balance to the new absolute value. + err = h.Handle(ctx, eventData(t, Swept, time.Now(), SweptData{ + PoolId: big.NewInt(0), + To: adminAddr, + Amount: big.NewInt(600), + NewBalance: big.NewInt(400), + })) + require.NoError(t, err) + + require.NoError(t, pool.Reload(ctx, h.DBS.DBS().Reader)) + assert.Equal(t, "400", pool.Balance.Big.String()) + + // Balance events for unknown pools are errors. + err = h.Handle(ctx, eventData(t, Funded, time.Now(), FundedData{ + PoolId: big.NewInt(99), + From: adminAddr, + Amount: big.NewInt(1000), + })) + assert.Error(t, err) +} + +func TestHandleRootSet(t *testing.T) { + tree, treeData := buildTree(t, 0, 214) + uri := "https://merkle.dimo.zone/pool-0/week-214.json" + + h, ctx := newTestHandler(t, &fakeFetcher{data: map[string][]byte{uri: treeData}}) + createPool(t, ctx, h, 0) + + setAt := time.Now() + root := tree.Root() + + err := h.Handle(ctx, eventData(t, RootSet, setAt, RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: root, + Allocation: big.NewInt(600), + ProofsURI: uri, + })) + require.NoError(t, err) + + dbRoot, err := models.FindMerkleRoot(ctx, h.DBS.DBS().Reader, 0, 214) + require.NoError(t, err) + assert.Equal(t, root[:], dbRoot.Root) + assert.Equal(t, "600", dbRoot.Allocation.Big.String()) + assert.Equal(t, 3, dbRoot.RecipientCount) + assert.Equal(t, 0, dbRoot.ClaimCount) + assert.Equal(t, "0", dbRoot.TotalClaimed.Big.String()) + assert.Equal(t, uri, dbRoot.ProofsURI) + assert.WithinDuration(t, setAt, dbRoot.SetAt, time.Second) + + claims, err := models.MerkleClaims().All(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.Len(t, claims, 3) + + claim, err := models.FindMerkleClaim(ctx, h.DBS.DBS().Reader, 0, 214, account1.Bytes()) + require.NoError(t, err) + assert.Equal(t, "100", claim.Amount.Big.String()) + assert.False(t, claim.ClaimedAt.Valid) + + proof, err := tree.Proof(account1) + require.NoError(t, err) + expected := make([]string, len(proof)) + for i, p := range proof { + expected[i] = p.Hex() + } + + var stored []string + require.NoError(t, json.Unmarshal(claim.Proof, &stored)) + assert.Equal(t, expected, stored) +} + +func TestHandleRootSetTamperedFile(t *testing.T) { + tree, treeData := buildTree(t, 0, 214) + uri := "https://merkle.dimo.zone/pool-0/week-214.json" + + // Tamper with a leaf amount so root verification fails. + var raw map[string]any + require.NoError(t, json.Unmarshal(treeData, &raw)) + leaves := raw["leaves"].([]any) + leaves[0].(map[string]any)["amount"] = "999" + tampered, err := json.Marshal(raw) + require.NoError(t, err) + + h, ctx := newTestHandler(t, &fakeFetcher{data: map[string][]byte{uri: tampered}}) + createPool(t, ctx, h, 0) + + err = h.Handle(ctx, eventData(t, RootSet, time.Now(), RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: tree.Root(), + Allocation: big.NewInt(600), + ProofsURI: uri, + })) + require.Error(t, err) + + // Nothing should have been written. + count, err := models.MerkleRoots().Count(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.Zero(t, count) + + count, err = models.MerkleClaims().Count(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.Zero(t, count) +} + +func TestHandleRootSetEventRootMismatch(t *testing.T) { + _, treeData := buildTree(t, 0, 214) + uri := "https://merkle.dimo.zone/pool-0/week-214.json" + + h, ctx := newTestHandler(t, &fakeFetcher{data: map[string][]byte{uri: treeData}}) + createPool(t, ctx, h, 0) + + // The file is internally consistent, but the on-chain root is different. + err := h.Handle(ctx, eventData(t, RootSet, time.Now(), RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"), + Allocation: big.NewInt(600), + ProofsURI: uri, + })) + require.Error(t, err) + + count, err := models.MerkleRoots().Count(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.Zero(t, count) +} + +func TestHandleClaimedIdempotent(t *testing.T) { + tree, treeData := buildTree(t, 0, 214) + uri := "https://merkle.dimo.zone/pool-0/week-214.json" + + h, ctx := newTestHandler(t, &fakeFetcher{data: map[string][]byte{uri: treeData}}) + createPool(t, ctx, h, 0) + + err := h.Handle(ctx, eventData(t, Funded, time.Now(), FundedData{ + PoolId: big.NewInt(0), + From: adminAddr, + Amount: big.NewInt(1000), + })) + require.NoError(t, err) + + err = h.Handle(ctx, eventData(t, RootSet, time.Now(), RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: tree.Root(), + Allocation: big.NewInt(600), + ProofsURI: uri, + })) + require.NoError(t, err) + + claimedAt := time.Now() + claimedEvent := eventData(t, Claimed, claimedAt, ClaimedData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Account: account1, + Amount: big.NewInt(100), + }) + + require.NoError(t, h.Handle(ctx, claimedEvent)) + + checkState := func() { + claim, err := models.FindMerkleClaim(ctx, h.DBS.DBS().Reader, 0, 214, account1.Bytes()) + require.NoError(t, err) + require.True(t, claim.ClaimedAt.Valid) + assert.WithinDuration(t, claimedAt, claim.ClaimedAt.Time, time.Second) + assert.Equal(t, claimedEvent.TransactionHash.Bytes(), claim.ClaimTX.Bytes) + + root, err := models.FindMerkleRoot(ctx, h.DBS.DBS().Reader, 0, 214) + require.NoError(t, err) + assert.Equal(t, 1, root.ClaimCount) + assert.Equal(t, "100", root.TotalClaimed.Big.String()) + + pool, err := models.FindMerklePool(ctx, h.DBS.DBS().Reader, 0) + require.NoError(t, err) + assert.Equal(t, "900", pool.Balance.Big.String()) + } + + checkState() + + // Redelivery of the same event must not double-count. + require.NoError(t, h.Handle(ctx, claimedEvent)) + checkState() + + // Setting the root again must preserve the claim state. + err = h.Handle(ctx, eventData(t, RootSet, time.Now(), RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: tree.Root(), + Allocation: big.NewInt(600), + ProofsURI: uri, + })) + require.NoError(t, err) + checkState() + + // A claim for a leaf we don't know about is an error. + err = h.Handle(ctx, eventData(t, Claimed, time.Now(), ClaimedData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Account: common.HexToAddress("0x5555555555555555555555555555555555555555"), + Amount: big.NewInt(50), + })) + assert.Error(t, err) +} diff --git a/internal/services/merkle_consumer_test.go b/internal/services/merkle_consumer_test.go new file mode 100644 index 00000000..b80df106 --- /dev/null +++ b/internal/services/merkle_consumer_test.go @@ -0,0 +1,57 @@ +package services + +import ( + "context" + "math/big" + "os" + "testing" + + "github.com/DIMO-Network/identity-api/internal/config" + "github.com/DIMO-Network/identity-api/internal/helpers" + "github.com/DIMO-Network/identity-api/internal/services/merkle" + "github.com/DIMO-Network/identity-api/models" + "github.com/ethereum/go-ethereum/common" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +const merkleDistributorAddr = "0x4f5e9320b1c7cB3DE5ebDD760aD67375B66cF8a4" + +// TestHandleMerklePoolCreatedEvent checks that the consumer routes +// MerkleDistributor events, addressed by the MERKLE_DISTRIBUTOR_ADDR setting, +// to the Merkle handler. +func TestHandleMerklePoolCreatedEvent(t *testing.T) { + ctx := context.Background() + logger := zerolog.New(os.Stdout).With().Timestamp().Str("app", helpers.DBSettings.Name).Logger() + + settings := config.Settings{ + DIMORegistryChainID: contractEventData.ChainID, + MerkleDistributorAddr: merkleDistributorAddr, + } + + pdb, _ := helpers.StartContainerDatabase(ctx, t, migrationsDirRelPath) + consumer := NewContractsEventsConsumer(pdb, &logger, &settings) + + eventData := contractEventData + eventData.EventName = merkle.PoolCreated + eventData.Contract = common.HexToAddress(merkleDistributorAddr) + + args := merkle.PoolCreatedData{ + PoolId: big.NewInt(0), + Token: common.HexToAddress("0xE261D618a959aFfFd53168Cd07D12E37B26761db"), + Admin: common.HexToAddress("0xaba3A41bd932244Dd08186e4c19F1a7E48cbcDf4"), + WeeklyLimit: big.NewInt(5000), + } + + e := prepareEvent(t, eventData, args) + + require.NoError(t, consumer.Process(ctx, &e)) + + pool, err := models.FindMerklePool(ctx, pdb.DBS().Reader, 0) + require.NoError(t, err) + assert.Equal(t, args.Token.Bytes(), pool.Token) + assert.Equal(t, args.Admin.Bytes(), pool.Admin) + assert.Equal(t, "5000", pool.WeeklyLimit.Big.String()) + assert.Equal(t, "0", pool.Balance.Big.String()) +} From ca3e31c394ee81979e2b4c9c2bfc7f1e9bab42c7 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:51:38 -0400 Subject: [PATCH 05/11] feat(graphql): serve Merkle pools, epochs, and rewards --- gqlgen.yml | 11 + graph/generated.go | 11476 +++++++++++------- graph/mcp_tools_gen.go | 2 +- graph/merkle.resolvers.go | 55 + graph/model/models_gen.go | 92 + graph/resolver.go | 3 + graph/schema/merkle.graphqls | 176 + internal/repositories/merkle/merkle.go | 417 + internal/repositories/merkle/merkle_test.go | 254 + 9 files changed, 8189 insertions(+), 4297 deletions(-) create mode 100644 graph/merkle.resolvers.go create mode 100644 graph/schema/merkle.graphqls create mode 100644 internal/repositories/merkle/merkle.go create mode 100644 internal/repositories/merkle/merkle_test.go diff --git a/gqlgen.yml b/gqlgen.yml index 24de30a3..c7d0e2a0 100644 --- a/gqlgen.yml +++ b/gqlgen.yml @@ -226,3 +226,14 @@ models: extraFields: VehicleID: type: "*int" + MerklePool: + fields: + epochs: + resolver: true + MerkleReward: + fields: + pool: + resolver: true + extraFields: + PoolID: + type: "int" diff --git a/graph/generated.go b/graph/generated.go index 76b1eb3a..ce02d194 100644 --- a/graph/generated.go +++ b/graph/generated.go @@ -40,6 +40,8 @@ type ResolverRoot interface { DeveloperLicense() DeveloperLicenseResolver Earning() EarningResolver Manufacturer() ManufacturerResolver + MerklePool() MerklePoolResolver + MerkleReward() MerkleRewardResolver Query() QueryResolver Stake() StakeResolver SyntheticDevice() SyntheticDeviceResolver @@ -248,6 +250,74 @@ type ComplexityRoot struct { Node func(childComplexity int) int } + MerkleEpoch struct { + Allocation func(childComplexity int) int + ClaimCount func(childComplexity int) int + Epoch func(childComplexity int) int + ProofsURI func(childComplexity int) int + RecipientCount func(childComplexity int) int + Root func(childComplexity int) int + SetAt func(childComplexity int) int + TotalClaimed func(childComplexity int) int + } + + MerkleEpochConnection struct { + Edges func(childComplexity int) int + Nodes func(childComplexity int) int + PageInfo func(childComplexity int) int + TotalCount func(childComplexity int) int + } + + MerkleEpochEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + MerklePool struct { + Admin func(childComplexity int) int + Balance func(childComplexity int) int + CreatedAt func(childComplexity int) int + Epochs func(childComplexity int, first *int, after *string, last *int, before *string) int + PoolID func(childComplexity int) int + Token func(childComplexity int) int + WeeklyLimit func(childComplexity int) int + } + + MerklePoolConnection struct { + Edges func(childComplexity int) int + Nodes func(childComplexity int) int + PageInfo func(childComplexity int) int + TotalCount func(childComplexity int) int + } + + MerklePoolEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + MerkleReward struct { + Account func(childComplexity int) int + Amount func(childComplexity int) int + ClaimTx func(childComplexity int) int + Claimed func(childComplexity int) int + ClaimedAt func(childComplexity int) int + Epoch func(childComplexity int) int + Pool func(childComplexity int) int + Proof func(childComplexity int) int + } + + MerkleRewardConnection struct { + Edges func(childComplexity int) int + Nodes func(childComplexity int) int + PageInfo func(childComplexity int) int + TotalCount func(childComplexity int) int + } + + MerkleRewardEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + PageInfo struct { EndCursor func(childComplexity int) int HasNextPage func(childComplexity int) int @@ -287,6 +357,9 @@ type ComplexityRoot struct { DeviceDefinition func(childComplexity int, by model.DeviceDefinitionBy) int Manufacturer func(childComplexity int, by model.ManufacturerBy) int Manufacturers func(childComplexity int) int + MerklePool func(childComplexity int, poolID int) int + MerklePools func(childComplexity int, first *int, after *string, last *int, before *string) int + MerkleRewards func(childComplexity int, account common.Address, poolID *int, claimed *bool, first *int, after *string, last *int, before *string) int Node func(childComplexity int, id string) int Rewards func(childComplexity int, user common.Address) int Stakes func(childComplexity int, first *int, after *string, last *int, before *string, filterBy *model.StakeFilterBy) int @@ -510,6 +583,12 @@ type ManufacturerResolver interface { AftermarketDevices(ctx context.Context, obj *model.Manufacturer, first *int, after *string, last *int, before *string, filterBy *model.AftermarketDevicesFilter) (*model.AftermarketDeviceConnection, error) DeviceDefinitions(ctx context.Context, obj *model.Manufacturer, first *int, after *string, last *int, before *string, filterBy *model.DeviceDefinitionFilter) (*model.DeviceDefinitionConnection, error) } +type MerklePoolResolver interface { + Epochs(ctx context.Context, obj *model.MerklePool, first *int, after *string, last *int, before *string) (*model.MerkleEpochConnection, error) +} +type MerkleRewardResolver interface { + Pool(ctx context.Context, obj *model.MerkleReward) (*model.MerklePool, error) +} type QueryResolver interface { Node(ctx context.Context, id string) (model.Node, error) AftermarketDevice(ctx context.Context, by model.AftermarketDeviceBy) (*model.AftermarketDevice, error) @@ -523,6 +602,9 @@ type QueryResolver interface { DeviceDefinition(ctx context.Context, by model.DeviceDefinitionBy) (*model.DeviceDefinition, error) Manufacturer(ctx context.Context, by model.ManufacturerBy) (*model.Manufacturer, error) Manufacturers(ctx context.Context) (*model.ManufacturerConnection, error) + MerklePools(ctx context.Context, first *int, after *string, last *int, before *string) (*model.MerklePoolConnection, error) + MerklePool(ctx context.Context, poolID int) (*model.MerklePool, error) + MerkleRewards(ctx context.Context, account common.Address, poolID *int, claimed *bool, first *int, after *string, last *int, before *string) (*model.MerkleRewardConnection, error) Rewards(ctx context.Context, user common.Address) (*model.UserRewards, error) Stakes(ctx context.Context, first *int, after *string, last *int, before *string, filterBy *model.StakeFilterBy) (*model.StakeConnection, error) SyntheticDevice(ctx context.Context, by model.SyntheticDeviceBy) (*model.SyntheticDevice, error) @@ -1354,6 +1436,266 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ManufacturerEdge.Node(childComplexity), true + case "MerkleEpoch.allocation": + if e.ComplexityRoot.MerkleEpoch.Allocation == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.Allocation(childComplexity), true + case "MerkleEpoch.claimCount": + if e.ComplexityRoot.MerkleEpoch.ClaimCount == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.ClaimCount(childComplexity), true + case "MerkleEpoch.epoch": + if e.ComplexityRoot.MerkleEpoch.Epoch == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.Epoch(childComplexity), true + case "MerkleEpoch.proofsURI": + if e.ComplexityRoot.MerkleEpoch.ProofsURI == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.ProofsURI(childComplexity), true + case "MerkleEpoch.recipientCount": + if e.ComplexityRoot.MerkleEpoch.RecipientCount == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.RecipientCount(childComplexity), true + case "MerkleEpoch.root": + if e.ComplexityRoot.MerkleEpoch.Root == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.Root(childComplexity), true + case "MerkleEpoch.setAt": + if e.ComplexityRoot.MerkleEpoch.SetAt == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.SetAt(childComplexity), true + case "MerkleEpoch.totalClaimed": + if e.ComplexityRoot.MerkleEpoch.TotalClaimed == nil { + break + } + + return e.ComplexityRoot.MerkleEpoch.TotalClaimed(childComplexity), true + + case "MerkleEpochConnection.edges": + if e.ComplexityRoot.MerkleEpochConnection.Edges == nil { + break + } + + return e.ComplexityRoot.MerkleEpochConnection.Edges(childComplexity), true + case "MerkleEpochConnection.nodes": + if e.ComplexityRoot.MerkleEpochConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.MerkleEpochConnection.Nodes(childComplexity), true + case "MerkleEpochConnection.pageInfo": + if e.ComplexityRoot.MerkleEpochConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.MerkleEpochConnection.PageInfo(childComplexity), true + case "MerkleEpochConnection.totalCount": + if e.ComplexityRoot.MerkleEpochConnection.TotalCount == nil { + break + } + + return e.ComplexityRoot.MerkleEpochConnection.TotalCount(childComplexity), true + + case "MerkleEpochEdge.cursor": + if e.ComplexityRoot.MerkleEpochEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.MerkleEpochEdge.Cursor(childComplexity), true + case "MerkleEpochEdge.node": + if e.ComplexityRoot.MerkleEpochEdge.Node == nil { + break + } + + return e.ComplexityRoot.MerkleEpochEdge.Node(childComplexity), true + + case "MerklePool.admin": + if e.ComplexityRoot.MerklePool.Admin == nil { + break + } + + return e.ComplexityRoot.MerklePool.Admin(childComplexity), true + case "MerklePool.balance": + if e.ComplexityRoot.MerklePool.Balance == nil { + break + } + + return e.ComplexityRoot.MerklePool.Balance(childComplexity), true + case "MerklePool.createdAt": + if e.ComplexityRoot.MerklePool.CreatedAt == nil { + break + } + + return e.ComplexityRoot.MerklePool.CreatedAt(childComplexity), true + case "MerklePool.epochs": + if e.ComplexityRoot.MerklePool.Epochs == nil { + break + } + + args, err := ec.field_MerklePool_epochs_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.MerklePool.Epochs(childComplexity, args["first"].(*int), args["after"].(*string), args["last"].(*int), args["before"].(*string)), true + case "MerklePool.poolId": + if e.ComplexityRoot.MerklePool.PoolID == nil { + break + } + + return e.ComplexityRoot.MerklePool.PoolID(childComplexity), true + case "MerklePool.token": + if e.ComplexityRoot.MerklePool.Token == nil { + break + } + + return e.ComplexityRoot.MerklePool.Token(childComplexity), true + case "MerklePool.weeklyLimit": + if e.ComplexityRoot.MerklePool.WeeklyLimit == nil { + break + } + + return e.ComplexityRoot.MerklePool.WeeklyLimit(childComplexity), true + + case "MerklePoolConnection.edges": + if e.ComplexityRoot.MerklePoolConnection.Edges == nil { + break + } + + return e.ComplexityRoot.MerklePoolConnection.Edges(childComplexity), true + case "MerklePoolConnection.nodes": + if e.ComplexityRoot.MerklePoolConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.MerklePoolConnection.Nodes(childComplexity), true + case "MerklePoolConnection.pageInfo": + if e.ComplexityRoot.MerklePoolConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.MerklePoolConnection.PageInfo(childComplexity), true + case "MerklePoolConnection.totalCount": + if e.ComplexityRoot.MerklePoolConnection.TotalCount == nil { + break + } + + return e.ComplexityRoot.MerklePoolConnection.TotalCount(childComplexity), true + + case "MerklePoolEdge.cursor": + if e.ComplexityRoot.MerklePoolEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.MerklePoolEdge.Cursor(childComplexity), true + case "MerklePoolEdge.node": + if e.ComplexityRoot.MerklePoolEdge.Node == nil { + break + } + + return e.ComplexityRoot.MerklePoolEdge.Node(childComplexity), true + + case "MerkleReward.account": + if e.ComplexityRoot.MerkleReward.Account == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Account(childComplexity), true + case "MerkleReward.amount": + if e.ComplexityRoot.MerkleReward.Amount == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Amount(childComplexity), true + case "MerkleReward.claimTx": + if e.ComplexityRoot.MerkleReward.ClaimTx == nil { + break + } + + return e.ComplexityRoot.MerkleReward.ClaimTx(childComplexity), true + case "MerkleReward.claimed": + if e.ComplexityRoot.MerkleReward.Claimed == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Claimed(childComplexity), true + case "MerkleReward.claimedAt": + if e.ComplexityRoot.MerkleReward.ClaimedAt == nil { + break + } + + return e.ComplexityRoot.MerkleReward.ClaimedAt(childComplexity), true + case "MerkleReward.epoch": + if e.ComplexityRoot.MerkleReward.Epoch == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Epoch(childComplexity), true + case "MerkleReward.pool": + if e.ComplexityRoot.MerkleReward.Pool == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Pool(childComplexity), true + case "MerkleReward.proof": + if e.ComplexityRoot.MerkleReward.Proof == nil { + break + } + + return e.ComplexityRoot.MerkleReward.Proof(childComplexity), true + + case "MerkleRewardConnection.edges": + if e.ComplexityRoot.MerkleRewardConnection.Edges == nil { + break + } + + return e.ComplexityRoot.MerkleRewardConnection.Edges(childComplexity), true + case "MerkleRewardConnection.nodes": + if e.ComplexityRoot.MerkleRewardConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.MerkleRewardConnection.Nodes(childComplexity), true + case "MerkleRewardConnection.pageInfo": + if e.ComplexityRoot.MerkleRewardConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.MerkleRewardConnection.PageInfo(childComplexity), true + case "MerkleRewardConnection.totalCount": + if e.ComplexityRoot.MerkleRewardConnection.TotalCount == nil { + break + } + + return e.ComplexityRoot.MerkleRewardConnection.TotalCount(childComplexity), true + + case "MerkleRewardEdge.cursor": + if e.ComplexityRoot.MerkleRewardEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.MerkleRewardEdge.Cursor(childComplexity), true + case "MerkleRewardEdge.node": + if e.ComplexityRoot.MerkleRewardEdge.Node == nil { + break + } + + return e.ComplexityRoot.MerkleRewardEdge.Node(childComplexity), true + case "PageInfo.endCursor": if e.ComplexityRoot.PageInfo.EndCursor == nil { break @@ -1570,6 +1912,39 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin } return e.ComplexityRoot.Query.Manufacturers(childComplexity), true + case "Query.merklePool": + if e.ComplexityRoot.Query.MerklePool == nil { + break + } + + args, err := ec.field_Query_merklePool_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.Query.MerklePool(childComplexity, args["poolId"].(int)), true + case "Query.merklePools": + if e.ComplexityRoot.Query.MerklePools == nil { + break + } + + args, err := ec.field_Query_merklePools_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.Query.MerklePools(childComplexity, args["first"].(*int), args["after"].(*string), args["last"].(*int), args["before"].(*string)), true + case "Query.merkleRewards": + if e.ComplexityRoot.Query.MerkleRewards == nil { + break + } + + args, err := ec.field_Query_merkleRewards_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.Query.MerkleRewards(childComplexity, args["account"].(common.Address), args["poolId"].(*int), args["claimed"].(*bool), args["first"].(*int), args["after"].(*string), args["last"].(*int), args["before"].(*string)), true case "Query.node": if e.ComplexityRoot.Query.Node == nil { break @@ -2451,7 +2826,7 @@ func newExecutionContext( } } -//go:embed "schema/aftermarket.graphqls" "schema/connection.graphqls" "schema/dcn.graphqls" "schema/developerlicense.graphqls" "schema/devicedefinition.graphqls" "schema/directives.graphqls" "schema/manufacturer.graphqls" "schema/privilege.graphqls" "schema/reward.graphqls" "schema/sacd.graphqls" "schema/schema.graphqls" "schema/stakes.graphqls" "schema/storagenode.graphqls" "schema/synthetic.graphqls" "schema/template.graphqls" "schema/user.graphqls" "schema/vehicle.graphqls" +//go:embed "schema/aftermarket.graphqls" "schema/connection.graphqls" "schema/dcn.graphqls" "schema/developerlicense.graphqls" "schema/devicedefinition.graphqls" "schema/directives.graphqls" "schema/manufacturer.graphqls" "schema/merkle.graphqls" "schema/privilege.graphqls" "schema/reward.graphqls" "schema/sacd.graphqls" "schema/schema.graphqls" "schema/stakes.graphqls" "schema/storagenode.graphqls" "schema/synthetic.graphqls" "schema/template.graphqls" "schema/user.graphqls" "schema/vehicle.graphqls" var sourcesFS embed.FS func sourceData(filename string) string { @@ -2470,6 +2845,7 @@ var sources = []*ast.Source{ {Name: "schema/devicedefinition.graphqls", Input: sourceData("schema/devicedefinition.graphqls"), BuiltIn: false}, {Name: "schema/directives.graphqls", Input: sourceData("schema/directives.graphqls"), BuiltIn: false}, {Name: "schema/manufacturer.graphqls", Input: sourceData("schema/manufacturer.graphqls"), BuiltIn: false}, + {Name: "schema/merkle.graphqls", Input: sourceData("schema/merkle.graphqls"), BuiltIn: false}, {Name: "schema/privilege.graphqls", Input: sourceData("schema/privilege.graphqls"), BuiltIn: false}, {Name: "schema/reward.graphqls", Input: sourceData("schema/reward.graphqls"), BuiltIn: false}, {Name: "schema/sacd.graphqls", Input: sourceData("schema/sacd.graphqls"), BuiltIn: false}, @@ -2653,6 +3029,32 @@ func (ec *executionContext) field_Manufacturer_deviceDefinitions_args(ctx contex return args, nil } +func (ec *executionContext) field_MerklePool_epochs_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["before"] = arg3 + return args, nil +} + func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} @@ -2860,29 +3262,18 @@ func (ec *executionContext) field_Query_manufacturer_args(ctx context.Context, r return args, nil } -func (ec *executionContext) field_Query_node_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { - var err error - args := map[string]any{} - arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id", ec.unmarshalNID2string) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} - -func (ec *executionContext) field_Query_rewards_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { +func (ec *executionContext) field_Query_merklePool_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} - arg0, err := graphql.ProcessArgField(ctx, rawArgs, "user", ec.unmarshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress) + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "poolId", ec.unmarshalNInt2int) if err != nil { return nil, err } - args["user"] = arg0 + args["poolId"] = arg0 return args, nil } -func (ec *executionContext) field_Query_stakes_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { +func (ec *executionContext) field_Query_merklePools_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) @@ -2905,43 +3296,132 @@ func (ec *executionContext) field_Query_stakes_args(ctx context.Context, rawArgs return nil, err } args["before"] = arg3 - arg4, err := graphql.ProcessArgField(ctx, rawArgs, "filterBy", ec.unmarshalOStakeFilterBy2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeFilterBy) - if err != nil { - return nil, err - } - args["filterBy"] = arg4 return args, nil } -func (ec *executionContext) field_Query_syntheticDevice_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { +func (ec *executionContext) field_Query_merkleRewards_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { var err error args := map[string]any{} - arg0, err := graphql.ProcessArgField(ctx, rawArgs, "by", ec.unmarshalNSyntheticDeviceBy2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceBy) + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "account", ec.unmarshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress) if err != nil { return nil, err } - args["by"] = arg0 - return args, nil -} - -func (ec *executionContext) field_Query_syntheticDevices_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { - var err error - args := map[string]any{} - arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + args["account"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "poolId", ec.unmarshalOInt2ᚖint) if err != nil { return nil, err } - args["first"] = arg0 - arg1, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + args["poolId"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "claimed", ec.unmarshalOBoolean2ᚖbool) if err != nil { return nil, err } - args["last"] = arg1 - arg2, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOString2ᚖstring) + args["claimed"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) if err != nil { return nil, err } - args["after"] = arg2 + args["first"] = arg3 + arg4, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["after"] = arg4 + arg5, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg5 + arg6, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["before"] = arg6 + return args, nil +} + +func (ec *executionContext) field_Query_node_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "id", ec.unmarshalNID2string) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} + +func (ec *executionContext) field_Query_rewards_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "user", ec.unmarshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress) + if err != nil { + return nil, err + } + args["user"] = arg0 + return args, nil +} + +func (ec *executionContext) field_Query_stakes_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["after"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg2 + arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["before"] = arg3 + arg4, err := graphql.ProcessArgField(ctx, rawArgs, "filterBy", ec.unmarshalOStakeFilterBy2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeFilterBy) + if err != nil { + return nil, err + } + args["filterBy"] = arg4 + return args, nil +} + +func (ec *executionContext) field_Query_syntheticDevice_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "by", ec.unmarshalNSyntheticDeviceBy2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceBy) + if err != nil { + return nil, err + } + args["by"] = arg0 + return args, nil +} + +func (ec *executionContext) field_Query_syntheticDevices_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) { + var err error + args := map[string]any{} + arg0, err := graphql.ProcessArgField(ctx, rawArgs, "first", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["first"] = arg0 + arg1, err := graphql.ProcessArgField(ctx, rawArgs, "last", ec.unmarshalOInt2ᚖint) + if err != nil { + return nil, err + } + args["last"] = arg1 + arg2, err := graphql.ProcessArgField(ctx, rawArgs, "after", ec.unmarshalOString2ᚖstring) + if err != nil { + return nil, err + } + args["after"] = arg2 arg3, err := graphql.ProcessArgField(ctx, rawArgs, "before", ec.unmarshalOString2ᚖstring) if err != nil { return nil, err @@ -7471,130 +7951,130 @@ func (ec *executionContext) fieldContext_ManufacturerEdge_cursor(_ context.Conte return fc, nil } -func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_epoch(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PageInfo_startCursor, + ec.fieldContext_MerkleEpoch_epoch, func(ctx context.Context) (any, error) { - return obj.StartCursor, nil + return obj.Epoch, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_PageInfo_startCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_epoch(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PageInfo", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_root(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PageInfo_endCursor, + ec.fieldContext_MerkleEpoch_root, func(ctx context.Context) (any, error) { - return obj.EndCursor, nil + return obj.Root, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNBytes2ᚕbyte, + true, true, - false, ) } -func (ec *executionContext) fieldContext_PageInfo_endCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_root(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PageInfo", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Bytes does not have child fields") }, } return fc, nil } -func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_allocation(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PageInfo_hasPreviousPage, + ec.fieldContext_MerkleEpoch_allocation, func(ctx context.Context) (any, error) { - return obj.HasPreviousPage, nil + return obj.Allocation, nil }, nil, - ec.marshalNBoolean2bool, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, true, true, ) } -func (ec *executionContext) fieldContext_PageInfo_hasPreviousPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_allocation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PageInfo", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type BigInt does not have child fields") }, } return fc, nil } -func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_totalClaimed(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PageInfo_hasNextPage, + ec.fieldContext_MerkleEpoch_totalClaimed, func(ctx context.Context) (any, error) { - return obj.HasNextPage, nil + return obj.TotalClaimed, nil }, nil, - ec.marshalNBoolean2bool, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, true, true, ) } -func (ec *executionContext) fieldContext_PageInfo_hasNextPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_totalClaimed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PageInfo", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type BigInt does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Privilege_id(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_claimCount(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Privilege_id, + ec.fieldContext_MerkleEpoch_claimCount, func(ctx context.Context) (any, error) { - return obj.ID, nil + return obj.ClaimCount, nil }, nil, ec.marshalNInt2int, @@ -7603,9 +8083,9 @@ func (ec *executionContext) _Privilege_id(ctx context.Context, field graphql.Col ) } -func (ec *executionContext) fieldContext_Privilege_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_claimCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Privilege", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, @@ -7616,72 +8096,72 @@ func (ec *executionContext) fieldContext_Privilege_id(_ context.Context, field g return fc, nil } -func (ec *executionContext) _Privilege_user(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_recipientCount(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Privilege_user, + ec.fieldContext_MerkleEpoch_recipientCount, func(ctx context.Context) (any, error) { - return obj.User, nil + return obj.RecipientCount, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_Privilege_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_recipientCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Privilege", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Privilege_setAt(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_proofsURI(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Privilege_setAt, + ec.fieldContext_MerkleEpoch_proofsURI, func(ctx context.Context) (any, error) { - return obj.SetAt, nil + return obj.ProofsURI, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_Privilege_setAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_proofsURI(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Privilege", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Privilege_expiresAt(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpoch_setAt(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpoch) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Privilege_expiresAt, + ec.fieldContext_MerkleEpoch_setAt, func(ctx context.Context) (any, error) { - return obj.ExpiresAt, nil + return obj.SetAt, nil }, nil, ec.marshalNTime2timeᚐTime, @@ -7690,9 +8170,9 @@ func (ec *executionContext) _Privilege_expiresAt(ctx context.Context, field grap ) } -func (ec *executionContext) fieldContext_Privilege_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpoch_setAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Privilege", + Object: "MerkleEpoch", Field: field, IsMethod: false, IsResolver: false, @@ -7703,477 +8183,441 @@ func (ec *executionContext) fieldContext_Privilege_expiresAt(_ context.Context, return fc, nil } -func (ec *executionContext) _PrivilegeEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegeEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegeEdge_node, + ec.fieldContext_MerkleEpochConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.TotalCount, nil }, nil, - ec.marshalNPrivilege2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilege, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegeEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegeEdge", + Object: "MerkleEpochConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Privilege_id(ctx, field) - case "user": - return ec.fieldContext_Privilege_user(ctx, field) - case "setAt": - return ec.fieldContext_Privilege_setAt(ctx, field) - case "expiresAt": - return ec.fieldContext_Privilege_expiresAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Privilege", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _PrivilegeEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegeEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegeEdge_cursor, + ec.fieldContext_MerkleEpochConnection_edges, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.Edges, nil }, nil, - ec.marshalNString2string, + ec.marshalNMerkleEpochEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegeEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegeEdge", + Object: "MerkleEpochConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_MerkleEpochEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_MerkleEpochEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerkleEpochEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _PrivilegesConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegesConnection_totalCount, + ec.fieldContext_MerkleEpochConnection_nodes, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + return obj.Nodes, nil }, nil, - ec.marshalNInt2int, + ec.marshalNMerkleEpoch2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochᚄ, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegesConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegesConnection", + Object: "MerkleEpochConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "epoch": + return ec.fieldContext_MerkleEpoch_epoch(ctx, field) + case "root": + return ec.fieldContext_MerkleEpoch_root(ctx, field) + case "allocation": + return ec.fieldContext_MerkleEpoch_allocation(ctx, field) + case "totalClaimed": + return ec.fieldContext_MerkleEpoch_totalClaimed(ctx, field) + case "claimCount": + return ec.fieldContext_MerkleEpoch_claimCount(ctx, field) + case "recipientCount": + return ec.fieldContext_MerkleEpoch_recipientCount(ctx, field) + case "proofsURI": + return ec.fieldContext_MerkleEpoch_proofsURI(ctx, field) + case "setAt": + return ec.fieldContext_MerkleEpoch_setAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerkleEpoch", field.Name) }, } return fc, nil } -func (ec *executionContext) _PrivilegesConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegesConnection_edges, + ec.fieldContext_MerkleEpochConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.Edges, nil + return obj.PageInfo, nil }, nil, - ec.marshalNPrivilegeEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegeEdgeᚄ, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegesConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegesConnection", + Object: "MerkleEpochConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "node": - return ec.fieldContext_PrivilegeEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_PrivilegeEdge_cursor(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type PrivilegeEdge", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _PrivilegesConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegesConnection_nodes, + ec.fieldContext_MerkleEpochEdge_node, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + return obj.Node, nil }, nil, - ec.marshalNPrivilege2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegeᚄ, + ec.marshalNMerkleEpoch2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpoch, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegesConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegesConnection", + Object: "MerkleEpochEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_Privilege_id(ctx, field) - case "user": - return ec.fieldContext_Privilege_user(ctx, field) + case "epoch": + return ec.fieldContext_MerkleEpoch_epoch(ctx, field) + case "root": + return ec.fieldContext_MerkleEpoch_root(ctx, field) + case "allocation": + return ec.fieldContext_MerkleEpoch_allocation(ctx, field) + case "totalClaimed": + return ec.fieldContext_MerkleEpoch_totalClaimed(ctx, field) + case "claimCount": + return ec.fieldContext_MerkleEpoch_claimCount(ctx, field) + case "recipientCount": + return ec.fieldContext_MerkleEpoch_recipientCount(ctx, field) + case "proofsURI": + return ec.fieldContext_MerkleEpoch_proofsURI(ctx, field) case "setAt": - return ec.fieldContext_Privilege_setAt(ctx, field) - case "expiresAt": - return ec.fieldContext_Privilege_expiresAt(ctx, field) + return ec.fieldContext_MerkleEpoch_setAt(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Privilege", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerkleEpoch", field.Name) }, } return fc, nil } -func (ec *executionContext) _PrivilegesConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleEpochEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.MerkleEpochEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_PrivilegesConnection_pageInfo, + ec.fieldContext_MerkleEpochEdge_cursor, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + return obj.Cursor, nil }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_PrivilegesConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleEpochEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "PrivilegesConnection", + Object: "MerkleEpochEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePool_poolId(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_node, + ec.fieldContext_MerklePool_poolId, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Node(ctx, fc.Args["id"].(string)) + return obj.PoolID, nil }, nil, - ec.marshalONode2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐNode, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePool_poolId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePool", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_node_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_aftermarketDevice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePool_token(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_aftermarketDevice, + ec.fieldContext_MerklePool_token, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().AftermarketDevice(ctx, fc.Args["by"].(model.AftermarketDeviceBy)) + return obj.Token, nil }, nil, - ec.marshalOAftermarketDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDevice, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_aftermarketDevice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePool_token(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePool", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_AftermarketDevice_id(ctx, field) - case "tokenId": - return ec.fieldContext_AftermarketDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_AftermarketDevice_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_AftermarketDevice_manufacturer(ctx, field) - case "address": - return ec.fieldContext_AftermarketDevice_address(ctx, field) - case "owner": - return ec.fieldContext_AftermarketDevice_owner(ctx, field) - case "serial": - return ec.fieldContext_AftermarketDevice_serial(ctx, field) - case "imei": - return ec.fieldContext_AftermarketDevice_imei(ctx, field) - case "devEUI": - return ec.fieldContext_AftermarketDevice_devEUI(ctx, field) - case "hardwareRevision": - return ec.fieldContext_AftermarketDevice_hardwareRevision(ctx, field) - case "mintedAt": - return ec.fieldContext_AftermarketDevice_mintedAt(ctx, field) - case "claimedAt": - return ec.fieldContext_AftermarketDevice_claimedAt(ctx, field) - case "vehicle": - return ec.fieldContext_AftermarketDevice_vehicle(ctx, field) - case "beneficiary": - return ec.fieldContext_AftermarketDevice_beneficiary(ctx, field) - case "name": - return ec.fieldContext_AftermarketDevice_name(ctx, field) - case "image": - return ec.fieldContext_AftermarketDevice_image(ctx, field) - case "earnings": - return ec.fieldContext_AftermarketDevice_earnings(ctx, field) - case "pairedAt": - return ec.fieldContext_AftermarketDevice_pairedAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type AftermarketDevice", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_aftermarketDevice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_aftermarketDevices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePool_admin(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_aftermarketDevices, + ec.fieldContext_MerklePool_admin, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().AftermarketDevices(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.AftermarketDevicesFilter)) + return obj.Admin, nil }, nil, - ec.marshalNAftermarketDeviceConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDeviceConnection, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_Query_aftermarketDevices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePool_admin(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePool", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_AftermarketDeviceConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_AftermarketDeviceConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_AftermarketDeviceConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_AftermarketDeviceConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type AftermarketDeviceConnection", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_aftermarketDevices_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err + return fc, nil +} + +func (ec *executionContext) _MerklePool_weeklyLimit(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_MerklePool_weeklyLimit, + func(ctx context.Context) (any, error) { + return obj.WeeklyLimit, nil + }, + nil, + ec.marshalOBigInt2ᚖmathᚋbigᚐInt, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_MerklePool_weeklyLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "MerklePool", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type BigInt does not have child fields") + }, } return fc, nil } -func (ec *executionContext) _Query_connections(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePool_balance(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_connections, + ec.fieldContext_MerklePool_balance, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Connections(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + return obj.Balance, nil }, nil, - ec.marshalNConnectionConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnectionConnection, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, true, true, ) } -func (ec *executionContext) fieldContext_Query_connections(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePool_balance(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePool", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_ConnectionConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_ConnectionConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_ConnectionConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_ConnectionConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ConnectionConnection", field.Name) + return nil, errors.New("field of type BigInt does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_connections_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err + return fc, nil +} + +func (ec *executionContext) _MerklePool_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_MerklePool_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_MerklePool_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "MerklePool", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, } return fc, nil } -func (ec *executionContext) _Query_connection(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePool_epochs(ctx context.Context, field graphql.CollectedField, obj *model.MerklePool) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_connection, + ec.fieldContext_MerklePool_epochs, func(ctx context.Context) (any, error) { fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Connection(ctx, fc.Args["by"].(model.ConnectionBy)) + return ec.Resolvers.MerklePool().Epochs(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalOConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnection, + ec.marshalNMerkleEpochConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochConnection, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_connection(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePool_epochs(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePool", Field: field, IsMethod: true, IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext_Connection_name(ctx, field) - case "address": - return ec.fieldContext_Connection_address(ctx, field) - case "owner": - return ec.fieldContext_Connection_owner(ctx, field) - case "tokenId": - return ec.fieldContext_Connection_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Connection_tokenDID(ctx, field) - case "mintedAt": - return ec.fieldContext_Connection_mintedAt(ctx, field) + case "totalCount": + return ec.fieldContext_MerkleEpochConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_MerkleEpochConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_MerkleEpochConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_MerkleEpochConnection_pageInfo(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Connection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerkleEpochConnection", field.Name) }, } defer func() { @@ -8183,2194 +8627,2340 @@ func (ec *executionContext) fieldContext_Query_connection(ctx context.Context, f } }() ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_connection_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + if fc.Args, err = ec.field_MerklePool_epochs_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { ec.Error(ctx, err) return fc, err } return fc, nil } -func (ec *executionContext) _Query_dcn(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_dcn, + ec.fieldContext_MerklePoolConnection_totalCount, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Dcn(ctx, fc.Args["by"].(model.DCNBy)) + return obj.TotalCount, nil }, nil, - ec.marshalODCN2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDcn, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_dcn(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_DCN_id(ctx, field) - case "node": - return ec.fieldContext_DCN_node(ctx, field) - case "tokenId": - return ec.fieldContext_DCN_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_DCN_tokenDID(ctx, field) - case "owner": - return ec.fieldContext_DCN_owner(ctx, field) - case "expiresAt": - return ec.fieldContext_DCN_expiresAt(ctx, field) - case "mintedAt": - return ec.fieldContext_DCN_mintedAt(ctx, field) - case "name": - return ec.fieldContext_DCN_name(ctx, field) - case "vehicle": - return ec.fieldContext_DCN_vehicle(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type DCN", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_dcn_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_dcns(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_dcns, + ec.fieldContext_MerklePoolConnection_edges, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Dcns(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.DCNFilter)) + return obj.Edges, nil }, nil, - ec.marshalNDCNConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDCNConnection, + ec.marshalNMerklePoolEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Query_dcns(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "totalCount": - return ec.fieldContext_DCNConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_DCNConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_DCNConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_DCNConnection_pageInfo(ctx, field) + case "node": + return ec.fieldContext_MerklePoolEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_MerklePoolEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type DCNConnection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerklePoolEdge", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_dcns_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_developerLicenses(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_developerLicenses, + ec.fieldContext_MerklePoolConnection_nodes, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().DeveloperLicenses(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.DeveloperLicenseFilterBy)) + return obj.Nodes, nil }, nil, - ec.marshalNDeveloperLicenseConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeveloperLicenseConnection, + ec.marshalNMerklePool2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Query_developerLicenses(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "totalCount": - return ec.fieldContext_DeveloperLicenseConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_DeveloperLicenseConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_DeveloperLicenseConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_DeveloperLicenseConnection_pageInfo(ctx, field) + case "poolId": + return ec.fieldContext_MerklePool_poolId(ctx, field) + case "token": + return ec.fieldContext_MerklePool_token(ctx, field) + case "admin": + return ec.fieldContext_MerklePool_admin(ctx, field) + case "weeklyLimit": + return ec.fieldContext_MerklePool_weeklyLimit(ctx, field) + case "balance": + return ec.fieldContext_MerklePool_balance(ctx, field) + case "createdAt": + return ec.fieldContext_MerklePool_createdAt(ctx, field) + case "epochs": + return ec.fieldContext_MerklePool_epochs(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type DeveloperLicenseConnection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerklePool", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_developerLicenses_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_developerLicense(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_developerLicense, + ec.fieldContext_MerklePoolConnection_pageInfo, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().DeveloperLicense(ctx, fc.Args["by"].(model.DeveloperLicenseBy)) + return obj.PageInfo, nil }, nil, - ec.marshalODeveloperLicense2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeveloperLicense, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_developerLicense(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "tokenId": - return ec.fieldContext_DeveloperLicense_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_DeveloperLicense_tokenDID(ctx, field) - case "owner": - return ec.fieldContext_DeveloperLicense_owner(ctx, field) - case "clientId": - return ec.fieldContext_DeveloperLicense_clientId(ctx, field) - case "alias": - return ec.fieldContext_DeveloperLicense_alias(ctx, field) - case "mintedAt": - return ec.fieldContext_DeveloperLicense_mintedAt(ctx, field) - case "signers": - return ec.fieldContext_DeveloperLicense_signers(ctx, field) - case "redirectURIs": - return ec.fieldContext_DeveloperLicense_redirectURIs(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type DeveloperLicense", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_developerLicense_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_deviceDefinition(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_deviceDefinition, + ec.fieldContext_MerklePoolEdge_node, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().DeviceDefinition(ctx, fc.Args["by"].(model.DeviceDefinitionBy)) + return obj.Node, nil }, nil, - ec.marshalODeviceDefinition2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeviceDefinition, + ec.marshalNMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_deviceDefinition(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolEdge", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "deviceDefinitionId": - return ec.fieldContext_DeviceDefinition_deviceDefinitionId(ctx, field) - case "legacyId": - return ec.fieldContext_DeviceDefinition_legacyId(ctx, field) - case "manufacturer": - return ec.fieldContext_DeviceDefinition_manufacturer(ctx, field) - case "model": - return ec.fieldContext_DeviceDefinition_model(ctx, field) - case "year": - return ec.fieldContext_DeviceDefinition_year(ctx, field) - case "deviceType": - return ec.fieldContext_DeviceDefinition_deviceType(ctx, field) - case "imageURI": - return ec.fieldContext_DeviceDefinition_imageURI(ctx, field) - case "attributes": - return ec.fieldContext_DeviceDefinition_attributes(ctx, field) + case "poolId": + return ec.fieldContext_MerklePool_poolId(ctx, field) + case "token": + return ec.fieldContext_MerklePool_token(ctx, field) + case "admin": + return ec.fieldContext_MerklePool_admin(ctx, field) + case "weeklyLimit": + return ec.fieldContext_MerklePool_weeklyLimit(ctx, field) + case "balance": + return ec.fieldContext_MerklePool_balance(ctx, field) + case "createdAt": + return ec.fieldContext_MerklePool_createdAt(ctx, field) + case "epochs": + return ec.fieldContext_MerklePool_epochs(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type DeviceDefinition", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerklePool", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_deviceDefinition_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_manufacturer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerklePoolEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.MerklePoolEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_manufacturer, + ec.fieldContext_MerklePoolEdge_cursor, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Manufacturer(ctx, fc.Args["by"].(model.ManufacturerBy)) + return obj.Cursor, nil }, nil, - ec.marshalOManufacturer2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturer, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_manufacturer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerklePoolEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerklePoolEdge", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Manufacturer_id(ctx, field) - case "tokenId": - return ec.fieldContext_Manufacturer_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Manufacturer_tokenDID(ctx, field) - case "name": - return ec.fieldContext_Manufacturer_name(ctx, field) - case "owner": - return ec.fieldContext_Manufacturer_owner(ctx, field) - case "tableId": - return ec.fieldContext_Manufacturer_tableId(ctx, field) - case "mintedAt": - return ec.fieldContext_Manufacturer_mintedAt(ctx, field) - case "aftermarketDevices": - return ec.fieldContext_Manufacturer_aftermarketDevices(ctx, field) - case "deviceDefinitions": - return ec.fieldContext_Manufacturer_deviceDefinitions(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Manufacturer", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_manufacturer_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_manufacturers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_pool(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_manufacturers, + ec.fieldContext_MerkleReward_pool, func(ctx context.Context) (any, error) { - return ec.Resolvers.Query().Manufacturers(ctx) + return ec.Resolvers.MerkleReward().Pool(ctx, obj) }, nil, - ec.marshalNManufacturerConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturerConnection, + ec.marshalNMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool, true, true, ) } -func (ec *executionContext) fieldContext_Query_manufacturers(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_pool(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, IsMethod: true, IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "totalCount": - return ec.fieldContext_ManufacturerConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_ManufacturerConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_ManufacturerConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_ManufacturerConnection_pageInfo(ctx, field) + case "poolId": + return ec.fieldContext_MerklePool_poolId(ctx, field) + case "token": + return ec.fieldContext_MerklePool_token(ctx, field) + case "admin": + return ec.fieldContext_MerklePool_admin(ctx, field) + case "weeklyLimit": + return ec.fieldContext_MerklePool_weeklyLimit(ctx, field) + case "balance": + return ec.fieldContext_MerklePool_balance(ctx, field) + case "createdAt": + return ec.fieldContext_MerklePool_createdAt(ctx, field) + case "epochs": + return ec.fieldContext_MerklePool_epochs(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ManufacturerConnection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerklePool", field.Name) }, } return fc, nil } -func (ec *executionContext) _Query_rewards(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_epoch(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_rewards, + ec.fieldContext_MerkleReward_epoch, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Rewards(ctx, fc.Args["user"].(common.Address)) + return obj.Epoch, nil }, nil, - ec.marshalOUserRewards2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐUserRewards, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_rewards(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_epoch(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalTokens": - return ec.fieldContext_UserRewards_totalTokens(ctx, field) - case "history": - return ec.fieldContext_UserRewards_history(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type UserRewards", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_rewards_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_stakes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_account(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_stakes, + ec.fieldContext_MerkleReward_account, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Stakes(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.StakeFilterBy)) + return obj.Account, nil }, nil, - ec.marshalOStakeConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeConnection, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_stakes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_account(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_StakeConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_StakeConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_StakeConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_StakeConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type StakeConnection", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_stakes_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_syntheticDevice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_amount(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_syntheticDevice, + ec.fieldContext_MerkleReward_amount, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().SyntheticDevice(ctx, fc.Args["by"].(model.SyntheticDeviceBy)) + return obj.Amount, nil }, nil, - ec.marshalOSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_syntheticDevice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_amount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_SyntheticDevice_id(ctx, field) - case "name": - return ec.fieldContext_SyntheticDevice_name(ctx, field) - case "tokenId": - return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) - case "integrationId": - return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) - case "address": - return ec.fieldContext_SyntheticDevice_address(ctx, field) - case "mintedAt": - return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) - case "vehicle": - return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) - case "connection": - return ec.fieldContext_SyntheticDevice_connection(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) + return nil, errors.New("field of type BigInt does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_syntheticDevice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_syntheticDevices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_proof(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_syntheticDevices, + ec.fieldContext_MerkleReward_proof, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().SyntheticDevices(ctx, fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.SyntheticDevicesFilter)) + return obj.Proof, nil }, nil, - ec.marshalNSyntheticDeviceConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceConnection, + ec.marshalNString2ᚕstringᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Query_syntheticDevices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_proof(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_SyntheticDeviceConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_SyntheticDeviceConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_SyntheticDeviceConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_SyntheticDeviceConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDeviceConnection", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_syntheticDevices_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_template(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_claimed(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_template, + ec.fieldContext_MerkleReward_claimed, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Template(ctx, fc.Args["by"].(model.TemplateBy)) + return obj.Claimed, nil }, nil, - ec.marshalOTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, + ec.marshalNBoolean2bool, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_template(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_claimed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "tokenId": - return ec.fieldContext_Template_tokenId(ctx, field) - case "creator": - return ec.fieldContext_Template_creator(ctx, field) - case "asset": - return ec.fieldContext_Template_asset(ctx, field) - case "permissions": - return ec.fieldContext_Template_permissions(ctx, field) - case "cid": - return ec.fieldContext_Template_cid(ctx, field) - case "createdAt": - return ec.fieldContext_Template_createdAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + return nil, errors.New("field of type Boolean does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_template_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_templates(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_claimedAt(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_templates, + ec.fieldContext_MerkleReward_claimedAt, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Templates(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + return obj.ClaimedAt, nil }, nil, - ec.marshalNTemplateConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateConnection, - true, + ec.marshalOTime2ᚖtimeᚐTime, true, + false, ) } -func (ec *executionContext) fieldContext_Query_templates(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_claimedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_TemplateConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_TemplateConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_TemplateConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_TemplateConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type TemplateConnection", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_templates_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_account(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleReward_claimTx(ctx context.Context, field graphql.CollectedField, obj *model.MerkleReward) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_account, + ec.fieldContext_MerkleReward_claimTx, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Account(ctx, fc.Args["by"].(model.AccountBy)) + return obj.ClaimTx, nil }, nil, - ec.marshalOAccount2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAccount, + ec.marshalOBytes2ᚕbyte, true, false, ) } -func (ec *executionContext) fieldContext_Query_account(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleReward_claimTx(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleReward", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "address": - return ec.fieldContext_Account_address(ctx, field) - case "sacds": - return ec.fieldContext_Account_sacds(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Account", field.Name) + return nil, errors.New("field of type Bytes does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_account_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_vehicle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_vehicle, + ec.fieldContext_MerkleRewardConnection_totalCount, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Vehicle(ctx, fc.Args["tokenId"].(*int), fc.Args["tokenDID"].(*string)) + return obj.TotalCount, nil }, nil, - ec.marshalOVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query_vehicle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleRewardConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Vehicle_id(ctx, field) - case "tokenId": - return ec.fieldContext_Vehicle_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Vehicle_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_Vehicle_manufacturer(ctx, field) - case "owner": - return ec.fieldContext_Vehicle_owner(ctx, field) - case "mintedAt": - return ec.fieldContext_Vehicle_mintedAt(ctx, field) - case "aftermarketDevice": - return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) - case "privileges": - return ec.fieldContext_Vehicle_privileges(ctx, field) - case "sacds": - return ec.fieldContext_Vehicle_sacds(ctx, field) - case "sacd": - return ec.fieldContext_Vehicle_sacd(ctx, field) - case "syntheticDevice": - return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) - case "definition": - return ec.fieldContext_Vehicle_definition(ctx, field) - case "dcn": - return ec.fieldContext_Vehicle_dcn(ctx, field) - case "name": - return ec.fieldContext_Vehicle_name(ctx, field) - case "imageURI": - return ec.fieldContext_Vehicle_imageURI(ctx, field) - case "image": - return ec.fieldContext_Vehicle_image(ctx, field) - case "earnings": - return ec.fieldContext_Vehicle_earnings(ctx, field) - case "dataURI": - return ec.fieldContext_Vehicle_dataURI(ctx, field) - case "stake": - return ec.fieldContext_Vehicle_stake(ctx, field) - case "storageNode": - return ec.fieldContext_Vehicle_storageNode(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_vehicle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query_vehicles(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query_vehicles, + ec.fieldContext_MerkleRewardConnection_edges, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Query().Vehicles(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.VehiclesFilter)) + return obj.Edges, nil }, nil, - ec.marshalNVehicleConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleConnection, + ec.marshalNMerkleRewardEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Query_vehicles(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleRewardConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "totalCount": - return ec.fieldContext_VehicleConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_VehicleConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_VehicleConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_VehicleConnection_pageInfo(ctx, field) + case "node": + return ec.fieldContext_MerkleRewardEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_MerkleRewardEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type VehicleConnection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerkleRewardEdge", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query_vehicles_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query___type, + ec.fieldContext_MerkleRewardConnection_nodes, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.IntrospectType(fc.Args["name"].(string)) + return obj.Nodes, nil }, nil, - ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalNMerkleReward2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardᚄ, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleRewardConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + case "pool": + return ec.fieldContext_MerkleReward_pool(ctx, field) + case "epoch": + return ec.fieldContext_MerkleReward_epoch(ctx, field) + case "account": + return ec.fieldContext_MerkleReward_account(ctx, field) + case "amount": + return ec.fieldContext_MerkleReward_amount(ctx, field) + case "proof": + return ec.fieldContext_MerkleReward_proof(ctx, field) + case "claimed": + return ec.fieldContext_MerkleReward_claimed(ctx, field) + case "claimedAt": + return ec.fieldContext_MerkleReward_claimedAt(ctx, field) + case "claimTx": + return ec.fieldContext_MerkleReward_claimTx(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type MerkleReward", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Query___schema, + ec.fieldContext_MerkleRewardConnection_pageInfo, func(ctx context.Context) (any, error) { - return ec.IntrospectSchema() + return obj.PageInfo, nil }, nil, - ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Query", + Object: "MerkleRewardConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "description": - return ec.fieldContext___Schema_description(ctx, field) - case "types": - return ec.fieldContext___Schema_types(ctx, field) - case "queryType": - return ec.fieldContext___Schema_queryType(ctx, field) - case "mutationType": - return ec.fieldContext___Schema_mutationType(ctx, field) - case "subscriptionType": - return ec.fieldContext___Schema_subscriptionType(ctx, field) - case "directives": - return ec.fieldContext___Schema_directives(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _RedirectURI_uri(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURI) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURI_uri, + ec.fieldContext_MerkleRewardEdge_node, func(ctx context.Context) (any, error) { - return obj.URI, nil + return obj.Node, nil }, nil, - ec.marshalNString2string, + ec.marshalNMerkleReward2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleReward, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURI_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURI", + Object: "MerkleRewardEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "pool": + return ec.fieldContext_MerkleReward_pool(ctx, field) + case "epoch": + return ec.fieldContext_MerkleReward_epoch(ctx, field) + case "account": + return ec.fieldContext_MerkleReward_account(ctx, field) + case "amount": + return ec.fieldContext_MerkleReward_amount(ctx, field) + case "proof": + return ec.fieldContext_MerkleReward_proof(ctx, field) + case "claimed": + return ec.fieldContext_MerkleReward_claimed(ctx, field) + case "claimedAt": + return ec.fieldContext_MerkleReward_claimedAt(ctx, field) + case "claimTx": + return ec.fieldContext_MerkleReward_claimTx(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerkleReward", field.Name) }, } return fc, nil } -func (ec *executionContext) _RedirectURI_enabledAt(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURI) (ret graphql.Marshaler) { +func (ec *executionContext) _MerkleRewardEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.MerkleRewardEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURI_enabledAt, + ec.fieldContext_MerkleRewardEdge_cursor, func(ctx context.Context) (any, error) { - return obj.EnabledAt, nil + return obj.Cursor, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURI_enabledAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_MerkleRewardEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURI", + Object: "MerkleRewardEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIConnection_totalCount, + ec.fieldContext_PageInfo_startCursor, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + return obj.StartCursor, nil }, nil, - ec.marshalNInt2int, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_RedirectURIConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PageInfo_startCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIConnection", + Object: "PageInfo", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIConnection_edges, + ec.fieldContext_PageInfo_endCursor, func(ctx context.Context) (any, error) { - return obj.Edges, nil + return obj.EndCursor, nil }, nil, - ec.marshalNRedirectURIEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURIEdgeᚄ, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_RedirectURIConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PageInfo_endCursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIConnection", + Object: "PageInfo", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "node": - return ec.fieldContext_RedirectURIEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_RedirectURIEdge_cursor(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type RedirectURIEdge", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIConnection_nodes, + ec.fieldContext_PageInfo_hasPreviousPage, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + return obj.HasPreviousPage, nil }, nil, - ec.marshalNRedirectURI2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURIᚄ, + ec.marshalNBoolean2bool, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURIConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PageInfo_hasPreviousPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIConnection", + Object: "PageInfo", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "uri": - return ec.fieldContext_RedirectURI_uri(ctx, field) - case "enabledAt": - return ec.fieldContext_RedirectURI_enabledAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type RedirectURI", field.Name) + return nil, errors.New("field of type Boolean does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *model.PageInfo) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIConnection_pageInfo, + ec.fieldContext_PageInfo_hasNextPage, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + return obj.HasNextPage, nil }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + ec.marshalNBoolean2bool, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURIConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PageInfo_hasNextPage(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIConnection", + Object: "PageInfo", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, errors.New("field of type Boolean does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Privilege_id(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIEdge_node, + ec.fieldContext_Privilege_id, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.ID, nil }, nil, - ec.marshalNRedirectURI2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURI, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURIEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Privilege_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIEdge", + Object: "Privilege", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "uri": - return ec.fieldContext_RedirectURI_uri(ctx, field) - case "enabledAt": - return ec.fieldContext_RedirectURI_enabledAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type RedirectURI", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _RedirectURIEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Privilege_user(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_RedirectURIEdge_cursor, + ec.fieldContext_Privilege_user, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.User, nil }, nil, - ec.marshalNString2string, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_RedirectURIEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Privilege_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "RedirectURIEdge", + Object: "Privilege", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Sacd_grantee(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _Privilege_setAt(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_grantee, + ec.fieldContext_Privilege_setAt, func(ctx context.Context) (any, error) { - return obj.Grantee, nil + return obj.SetAt, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_Sacd_grantee(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Privilege_setAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "Privilege", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Sacd_permissions(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _Privilege_expiresAt(ctx context.Context, field graphql.CollectedField, obj *model.Privilege) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_permissions, + ec.fieldContext_Privilege_expiresAt, func(ctx context.Context) (any, error) { - return obj.Permissions, nil + return obj.ExpiresAt, nil }, nil, - ec.marshalNString2string, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_Sacd_permissions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Privilege_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "Privilege", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Sacd_source(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegeEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegeEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_source, + ec.fieldContext_PrivilegeEdge_node, func(ctx context.Context) (any, error) { - return obj.Source, nil + return obj.Node, nil }, nil, - ec.marshalNString2string, + ec.marshalNPrivilege2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilege, true, true, ) } -func (ec *executionContext) fieldContext_Sacd_source(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegeEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "PrivilegeEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "id": + return ec.fieldContext_Privilege_id(ctx, field) + case "user": + return ec.fieldContext_Privilege_user(ctx, field) + case "setAt": + return ec.fieldContext_Privilege_setAt(ctx, field) + case "expiresAt": + return ec.fieldContext_Privilege_expiresAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Privilege", field.Name) }, } return fc, nil } -func (ec *executionContext) _Sacd_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegeEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegeEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_createdAt, + ec.fieldContext_PrivilegeEdge_cursor, func(ctx context.Context) (any, error) { - return obj.CreatedAt, nil + return obj.Cursor, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_Sacd_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegeEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "PrivilegeEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Sacd_expiresAt(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegesConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_expiresAt, + ec.fieldContext_PrivilegesConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.ExpiresAt, nil + return obj.TotalCount, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_Sacd_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegesConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "PrivilegesConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Sacd_template(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegesConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Sacd_template, + ec.fieldContext_PrivilegesConnection_edges, func(ctx context.Context) (any, error) { - return obj.Template, nil + return obj.Edges, nil }, nil, - ec.marshalOTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, + ec.marshalNPrivilegeEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegeEdgeᚄ, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Sacd_template(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegesConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Sacd", + Object: "PrivilegesConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "tokenId": - return ec.fieldContext_Template_tokenId(ctx, field) - case "creator": - return ec.fieldContext_Template_creator(ctx, field) - case "asset": - return ec.fieldContext_Template_asset(ctx, field) - case "permissions": - return ec.fieldContext_Template_permissions(ctx, field) - case "cid": - return ec.fieldContext_Template_cid(ctx, field) - case "createdAt": - return ec.fieldContext_Template_createdAt(ctx, field) + case "node": + return ec.fieldContext_PrivilegeEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_PrivilegeEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PrivilegeEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _SacdConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegesConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdConnection_totalCount, + ec.fieldContext_PrivilegesConnection_nodes, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + return obj.Nodes, nil }, nil, - ec.marshalNInt2int, + ec.marshalNPrivilege2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_SacdConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegesConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdConnection", + Object: "PrivilegesConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "id": + return ec.fieldContext_Privilege_id(ctx, field) + case "user": + return ec.fieldContext_Privilege_user(ctx, field) + case "setAt": + return ec.fieldContext_Privilege_setAt(ctx, field) + case "expiresAt": + return ec.fieldContext_Privilege_expiresAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Privilege", field.Name) }, } return fc, nil } -func (ec *executionContext) _SacdConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _PrivilegesConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.PrivilegesConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdConnection_edges, + ec.fieldContext_PrivilegesConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.Edges, nil + return obj.PageInfo, nil }, nil, - ec.marshalNSacdEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdEdgeᚄ, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_SacdConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_PrivilegesConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdConnection", + Object: "PrivilegesConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "node": - return ec.fieldContext_SacdEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_SacdEdge_cursor(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type SacdEdge", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _SacdConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_node(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdConnection_nodes, + ec.fieldContext_Query_node, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Node(ctx, fc.Args["id"].(string)) }, nil, - ec.marshalNSacd2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdᚄ, - true, + ec.marshalONode2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐNode, true, + false, ) } -func (ec *executionContext) fieldContext_SacdConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_node(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "grantee": - return ec.fieldContext_Sacd_grantee(ctx, field) - case "permissions": - return ec.fieldContext_Sacd_permissions(ctx, field) - case "source": - return ec.fieldContext_Sacd_source(ctx, field) - case "createdAt": - return ec.fieldContext_Sacd_createdAt(ctx, field) - case "expiresAt": - return ec.fieldContext_Sacd_expiresAt(ctx, field) - case "template": - return ec.fieldContext_Sacd_template(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) + return nil, errors.New("FieldContext.Child cannot be called on type INTERFACE") }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_node_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SacdConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_aftermarketDevice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdConnection_pageInfo, + ec.fieldContext_Query_aftermarketDevice, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().AftermarketDevice(ctx, fc.Args["by"].(model.AftermarketDeviceBy)) }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, - true, + ec.marshalOAftermarketDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDevice, true, + false, ) } -func (ec *executionContext) fieldContext_SacdConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_aftermarketDevice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + case "id": + return ec.fieldContext_AftermarketDevice_id(ctx, field) + case "tokenId": + return ec.fieldContext_AftermarketDevice_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_AftermarketDevice_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_AftermarketDevice_manufacturer(ctx, field) + case "address": + return ec.fieldContext_AftermarketDevice_address(ctx, field) + case "owner": + return ec.fieldContext_AftermarketDevice_owner(ctx, field) + case "serial": + return ec.fieldContext_AftermarketDevice_serial(ctx, field) + case "imei": + return ec.fieldContext_AftermarketDevice_imei(ctx, field) + case "devEUI": + return ec.fieldContext_AftermarketDevice_devEUI(ctx, field) + case "hardwareRevision": + return ec.fieldContext_AftermarketDevice_hardwareRevision(ctx, field) + case "mintedAt": + return ec.fieldContext_AftermarketDevice_mintedAt(ctx, field) + case "claimedAt": + return ec.fieldContext_AftermarketDevice_claimedAt(ctx, field) + case "vehicle": + return ec.fieldContext_AftermarketDevice_vehicle(ctx, field) + case "beneficiary": + return ec.fieldContext_AftermarketDevice_beneficiary(ctx, field) + case "name": + return ec.fieldContext_AftermarketDevice_name(ctx, field) + case "image": + return ec.fieldContext_AftermarketDevice_image(ctx, field) + case "earnings": + return ec.fieldContext_AftermarketDevice_earnings(ctx, field) + case "pairedAt": + return ec.fieldContext_AftermarketDevice_pairedAt(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, fmt.Errorf("no field named %q was found under type AftermarketDevice", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_aftermarketDevice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SacdEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SacdEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_aftermarketDevices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdEdge_node, + ec.fieldContext_Query_aftermarketDevices, func(ctx context.Context) (any, error) { - return obj.Node, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().AftermarketDevices(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.AftermarketDevicesFilter)) }, nil, - ec.marshalNSacd2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacd, + ec.marshalNAftermarketDeviceConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDeviceConnection, true, true, ) } -func (ec *executionContext) fieldContext_SacdEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_aftermarketDevices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdEdge", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "grantee": - return ec.fieldContext_Sacd_grantee(ctx, field) - case "permissions": - return ec.fieldContext_Sacd_permissions(ctx, field) - case "source": - return ec.fieldContext_Sacd_source(ctx, field) - case "createdAt": - return ec.fieldContext_Sacd_createdAt(ctx, field) - case "expiresAt": - return ec.fieldContext_Sacd_expiresAt(ctx, field) - case "template": - return ec.fieldContext_Sacd_template(ctx, field) + case "totalCount": + return ec.fieldContext_AftermarketDeviceConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_AftermarketDeviceConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_AftermarketDeviceConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_AftermarketDeviceConnection_pageInfo(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) + return nil, fmt.Errorf("no field named %q was found under type AftermarketDeviceConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_aftermarketDevices_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SacdEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SacdEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_connections(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SacdEdge_cursor, + ec.fieldContext_Query_connections, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Connections(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalNString2string, + ec.marshalNConnectionConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnectionConnection, true, true, ) } -func (ec *executionContext) fieldContext_SacdEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_connections(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SacdEdge", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_ConnectionConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_ConnectionConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_ConnectionConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_ConnectionConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConnectionConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_connections_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Signer_address(ctx context.Context, field graphql.CollectedField, obj *model.Signer) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_connection(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Signer_address, + ec.fieldContext_Query_connection, func(ctx context.Context) (any, error) { - return obj.Address, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Connection(ctx, fc.Args["by"].(model.ConnectionBy)) }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, - true, + ec.marshalOConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnection, true, + false, ) } -func (ec *executionContext) fieldContext_Signer_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_connection(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Signer", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "name": + return ec.fieldContext_Connection_name(ctx, field) + case "address": + return ec.fieldContext_Connection_address(ctx, field) + case "owner": + return ec.fieldContext_Connection_owner(ctx, field) + case "tokenId": + return ec.fieldContext_Connection_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Connection_tokenDID(ctx, field) + case "mintedAt": + return ec.fieldContext_Connection_mintedAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Connection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_connection_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Signer_enabledAt(ctx context.Context, field graphql.CollectedField, obj *model.Signer) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_dcn(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Signer_enabledAt, + ec.fieldContext_Query_dcn, func(ctx context.Context) (any, error) { - return obj.EnabledAt, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Dcn(ctx, fc.Args["by"].(model.DCNBy)) }, nil, - ec.marshalNTime2timeᚐTime, - true, + ec.marshalODCN2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDcn, true, + false, ) } -func (ec *executionContext) fieldContext_Signer_enabledAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_dcn(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Signer", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_DCN_id(ctx, field) + case "node": + return ec.fieldContext_DCN_node(ctx, field) + case "tokenId": + return ec.fieldContext_DCN_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_DCN_tokenDID(ctx, field) + case "owner": + return ec.fieldContext_DCN_owner(ctx, field) + case "expiresAt": + return ec.fieldContext_DCN_expiresAt(ctx, field) + case "mintedAt": + return ec.fieldContext_DCN_mintedAt(ctx, field) + case "name": + return ec.fieldContext_DCN_name(ctx, field) + case "vehicle": + return ec.fieldContext_DCN_vehicle(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DCN", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_dcn_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SignerConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_dcns(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerConnection_totalCount, + ec.fieldContext_Query_dcns, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Dcns(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.DCNFilter)) }, nil, - ec.marshalNInt2int, + ec.marshalNDCNConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDCNConnection, true, true, ) } -func (ec *executionContext) fieldContext_SignerConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_dcns(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_DCNConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_DCNConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_DCNConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_DCNConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DCNConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_dcns_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SignerConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_developerLicenses(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerConnection_edges, + ec.fieldContext_Query_developerLicenses, func(ctx context.Context) (any, error) { - return obj.Edges, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().DeveloperLicenses(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.DeveloperLicenseFilterBy)) }, nil, - ec.marshalNSignerEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSignerEdgeᚄ, + ec.marshalNDeveloperLicenseConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeveloperLicenseConnection, true, true, ) } -func (ec *executionContext) fieldContext_SignerConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_developerLicenses(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "node": - return ec.fieldContext_SignerEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_SignerEdge_cursor(ctx, field) + case "totalCount": + return ec.fieldContext_DeveloperLicenseConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_DeveloperLicenseConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_DeveloperLicenseConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_DeveloperLicenseConnection_pageInfo(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type SignerEdge", field.Name) + return nil, fmt.Errorf("no field named %q was found under type DeveloperLicenseConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_developerLicenses_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SignerConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_developerLicense(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerConnection_nodes, + ec.fieldContext_Query_developerLicense, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().DeveloperLicense(ctx, fc.Args["by"].(model.DeveloperLicenseBy)) }, nil, - ec.marshalNSigner2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSignerᚄ, - true, + ec.marshalODeveloperLicense2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeveloperLicense, true, + false, ) } -func (ec *executionContext) fieldContext_SignerConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_developerLicense(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "address": - return ec.fieldContext_Signer_address(ctx, field) - case "enabledAt": - return ec.fieldContext_Signer_enabledAt(ctx, field) + case "tokenId": + return ec.fieldContext_DeveloperLicense_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_DeveloperLicense_tokenDID(ctx, field) + case "owner": + return ec.fieldContext_DeveloperLicense_owner(ctx, field) + case "clientId": + return ec.fieldContext_DeveloperLicense_clientId(ctx, field) + case "alias": + return ec.fieldContext_DeveloperLicense_alias(ctx, field) + case "mintedAt": + return ec.fieldContext_DeveloperLicense_mintedAt(ctx, field) + case "signers": + return ec.fieldContext_DeveloperLicense_signers(ctx, field) + case "redirectURIs": + return ec.fieldContext_DeveloperLicense_redirectURIs(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Signer", field.Name) + return nil, fmt.Errorf("no field named %q was found under type DeveloperLicense", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_developerLicense_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SignerConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_deviceDefinition(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerConnection_pageInfo, + ec.fieldContext_Query_deviceDefinition, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().DeviceDefinition(ctx, fc.Args["by"].(model.DeviceDefinitionBy)) }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, - true, + ec.marshalODeviceDefinition2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDeviceDefinition, true, + false, ) } -func (ec *executionContext) fieldContext_SignerConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_deviceDefinition(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + case "deviceDefinitionId": + return ec.fieldContext_DeviceDefinition_deviceDefinitionId(ctx, field) + case "legacyId": + return ec.fieldContext_DeviceDefinition_legacyId(ctx, field) + case "manufacturer": + return ec.fieldContext_DeviceDefinition_manufacturer(ctx, field) + case "model": + return ec.fieldContext_DeviceDefinition_model(ctx, field) + case "year": + return ec.fieldContext_DeviceDefinition_year(ctx, field) + case "deviceType": + return ec.fieldContext_DeviceDefinition_deviceType(ctx, field) + case "imageURI": + return ec.fieldContext_DeviceDefinition_imageURI(ctx, field) + case "attributes": + return ec.fieldContext_DeviceDefinition_attributes(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, fmt.Errorf("no field named %q was found under type DeviceDefinition", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_deviceDefinition_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _SignerEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SignerEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_manufacturer(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerEdge_node, + ec.fieldContext_Query_manufacturer, func(ctx context.Context) (any, error) { - return obj.Node, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Manufacturer(ctx, fc.Args["by"].(model.ManufacturerBy)) }, nil, - ec.marshalNSigner2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSigner, - true, + ec.marshalOManufacturer2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturer, true, + false, ) } -func (ec *executionContext) fieldContext_SignerEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_manufacturer(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerEdge", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "address": - return ec.fieldContext_Signer_address(ctx, field) - case "enabledAt": - return ec.fieldContext_Signer_enabledAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Signer", field.Name) - }, - } - return fc, nil -} - -func (ec *executionContext) _SignerEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SignerEdge) (ret graphql.Marshaler) { + case "id": + return ec.fieldContext_Manufacturer_id(ctx, field) + case "tokenId": + return ec.fieldContext_Manufacturer_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Manufacturer_tokenDID(ctx, field) + case "name": + return ec.fieldContext_Manufacturer_name(ctx, field) + case "owner": + return ec.fieldContext_Manufacturer_owner(ctx, field) + case "tableId": + return ec.fieldContext_Manufacturer_tableId(ctx, field) + case "mintedAt": + return ec.fieldContext_Manufacturer_mintedAt(ctx, field) + case "aftermarketDevices": + return ec.fieldContext_Manufacturer_aftermarketDevices(ctx, field) + case "deviceDefinitions": + return ec.fieldContext_Manufacturer_deviceDefinitions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Manufacturer", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_manufacturer_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Query_manufacturers(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SignerEdge_cursor, + ec.fieldContext_Query_manufacturers, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return ec.Resolvers.Query().Manufacturers(ctx) }, nil, - ec.marshalNString2string, + ec.marshalNManufacturerConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturerConnection, true, true, ) } -func (ec *executionContext) fieldContext_SignerEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_manufacturers(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SignerEdge", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_ManufacturerConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_ManufacturerConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_ManufacturerConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_ManufacturerConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ManufacturerConnection", field.Name) }, } return fc, nil } -func (ec *executionContext) _Stake_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_merklePools(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_tokenId, + ec.fieldContext_Query_merklePools, func(ctx context.Context) (any, error) { - return obj.TokenID, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().MerklePools(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalNInt2int, + ec.marshalNMerklePoolConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolConnection, true, true, ) } -func (ec *executionContext) fieldContext_Stake_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_merklePools(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_MerklePoolConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_MerklePoolConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_MerklePoolConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_MerklePoolConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerklePoolConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_merklePools_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_merklePool(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_tokenDID, + ec.fieldContext_Query_merklePool, func(ctx context.Context) (any, error) { - return obj.TokenDID, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().MerklePool(ctx, fc.Args["poolId"].(int)) }, nil, - ec.marshalNString2string, - true, + ec.marshalOMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool, true, + false, ) } -func (ec *executionContext) fieldContext_Stake_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_merklePool(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "poolId": + return ec.fieldContext_MerklePool_poolId(ctx, field) + case "token": + return ec.fieldContext_MerklePool_token(ctx, field) + case "admin": + return ec.fieldContext_MerklePool_admin(ctx, field) + case "weeklyLimit": + return ec.fieldContext_MerklePool_weeklyLimit(ctx, field) + case "balance": + return ec.fieldContext_MerklePool_balance(ctx, field) + case "createdAt": + return ec.fieldContext_MerklePool_createdAt(ctx, field) + case "epochs": + return ec.fieldContext_MerklePool_epochs(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerklePool", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_merklePool_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_owner(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_merkleRewards(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_owner, + ec.fieldContext_Query_merkleRewards, func(ctx context.Context) (any, error) { - return obj.Owner, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().MerkleRewards(ctx, fc.Args["account"].(common.Address), fc.Args["poolId"].(*int), fc.Args["claimed"].(*bool), fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNMerkleRewardConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardConnection, true, true, ) } -func (ec *executionContext) fieldContext_Stake_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_merkleRewards(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_MerkleRewardConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_MerkleRewardConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_MerkleRewardConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_MerkleRewardConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type MerkleRewardConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_merkleRewards_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_level(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_rewards(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_level, + ec.fieldContext_Query_rewards, func(ctx context.Context) (any, error) { - return obj.Level, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Rewards(ctx, fc.Args["user"].(common.Address)) }, nil, - ec.marshalNInt2int, - true, + ec.marshalOUserRewards2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐUserRewards, true, + false, ) } -func (ec *executionContext) fieldContext_Stake_level(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_rewards(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "totalTokens": + return ec.fieldContext_UserRewards_totalTokens(ctx, field) + case "history": + return ec.fieldContext_UserRewards_history(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type UserRewards", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_rewards_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_points(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_stakes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_points, + ec.fieldContext_Query_stakes, func(ctx context.Context) (any, error) { - return obj.Points, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Stakes(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.StakeFilterBy)) }, nil, - ec.marshalNInt2int, - true, + ec.marshalOStakeConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeConnection, true, + false, ) } -func (ec *executionContext) fieldContext_Stake_points(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_stakes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_StakeConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_StakeConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_StakeConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_StakeConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type StakeConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_stakes_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_amount(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_syntheticDevice(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_amount, + ec.fieldContext_Query_syntheticDevice, func(ctx context.Context) (any, error) { - return obj.Amount, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().SyntheticDevice(ctx, fc.Args["by"].(model.SyntheticDeviceBy)) }, nil, - ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, - true, + ec.marshalOSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, true, + false, ) } -func (ec *executionContext) fieldContext_Stake_amount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_syntheticDevice(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type BigDecimal does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _Stake_stakedAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { + switch field.Name { + case "id": + return ec.fieldContext_SyntheticDevice_id(ctx, field) + case "name": + return ec.fieldContext_SyntheticDevice_name(ctx, field) + case "tokenId": + return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) + case "integrationId": + return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) + case "address": + return ec.fieldContext_SyntheticDevice_address(ctx, field) + case "mintedAt": + return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) + case "vehicle": + return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) + case "connection": + return ec.fieldContext_SyntheticDevice_connection(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_syntheticDevice_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Query_syntheticDevices(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_stakedAt, + ec.fieldContext_Query_syntheticDevices, func(ctx context.Context) (any, error) { - return obj.StakedAt, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().SyntheticDevices(ctx, fc.Args["first"].(*int), fc.Args["last"].(*int), fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.SyntheticDevicesFilter)) }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNSyntheticDeviceConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceConnection, true, true, ) } -func (ec *executionContext) fieldContext_Stake_stakedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_syntheticDevices(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_SyntheticDeviceConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_SyntheticDeviceConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_SyntheticDeviceConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_SyntheticDeviceConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type SyntheticDeviceConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_syntheticDevices_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_endsAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_template(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_endsAt, + ec.fieldContext_Query_template, func(ctx context.Context) (any, error) { - return obj.EndsAt, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Template(ctx, fc.Args["by"].(model.TemplateBy)) }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalOTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_Query_template(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "tokenId": + return ec.fieldContext_Template_tokenId(ctx, field) + case "creator": + return ec.fieldContext_Template_creator(ctx, field) + case "asset": + return ec.fieldContext_Template_asset(ctx, field) + case "permissions": + return ec.fieldContext_Template_permissions(ctx, field) + case "cid": + return ec.fieldContext_Template_cid(ctx, field) + case "createdAt": + return ec.fieldContext_Template_createdAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_template_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Query_templates(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_Query_templates, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Templates(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + }, + nil, + ec.marshalNTemplateConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateConnection, true, true, ) } -func (ec *executionContext) fieldContext_Stake_endsAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_templates(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_TemplateConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_TemplateConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_TemplateConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_TemplateConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type TemplateConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_templates_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_withdrawnAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_account(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_withdrawnAt, + ec.fieldContext_Query_account, func(ctx context.Context) (any, error) { - return obj.WithdrawnAt, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Account(ctx, fc.Args["by"].(model.AccountBy)) }, nil, - ec.marshalOTime2ᚖtimeᚐTime, + ec.marshalOAccount2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAccount, true, false, ) } -func (ec *executionContext) fieldContext_Stake_withdrawnAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_account(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + switch field.Name { + case "address": + return ec.fieldContext_Account_address(ctx, field) + case "sacds": + return ec.fieldContext_Account_sacds(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Account", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_account_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _Stake_vehicle(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_vehicle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Stake_vehicle, + ec.fieldContext_Query_vehicle, func(ctx context.Context) (any, error) { - return ec.Resolvers.Stake().Vehicle(ctx, obj) + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Vehicle(ctx, fc.Args["tokenId"].(*int), fc.Args["tokenDID"].(*string)) }, nil, ec.marshalOVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, @@ -10379,9 +10969,9 @@ func (ec *executionContext) _Stake_vehicle(ctx context.Context, field graphql.Co ) } -func (ec *executionContext) fieldContext_Stake_vehicle(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_vehicle(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Stake", + Object: "Query", Field: field, IsMethod: true, IsResolver: true, @@ -10431,367 +11021,418 @@ func (ec *executionContext) fieldContext_Stake_vehicle(_ context.Context, field return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_vehicle_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _StakeConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_vehicles(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StakeConnection_totalCount, + ec.fieldContext_Query_vehicles, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Query().Vehicles(ctx, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.VehiclesFilter)) }, nil, - ec.marshalNInt2int, + ec.marshalNVehicleConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleConnection, true, true, ) } -func (ec *executionContext) fieldContext_StakeConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query_vehicles(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeConnection", + Object: "Query", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _StakeConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, + switch field.Name { + case "totalCount": + return ec.fieldContext_VehicleConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_VehicleConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_VehicleConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_VehicleConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type VehicleConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_vehicles_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, field, - ec.fieldContext_StakeConnection_edges, + ec.fieldContext_Query___type, func(ctx context.Context) (any, error) { - return obj.Edges, nil + fc := graphql.GetFieldContext(ctx) + return ec.IntrospectType(fc.Args["name"].(string)) }, nil, - ec.marshalNStakeEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeEdgeᚄ, - true, + ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, true, + false, ) } -func (ec *executionContext) fieldContext_StakeConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeConnection", + Object: "Query", Field: field, - IsMethod: false, + IsMethod: true, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "node": - return ec.fieldContext_StakeEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_StakeEdge_cursor(ctx, field) + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type StakeEdge", field.Name) + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) _StakeConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StakeConnection_nodes, + ec.fieldContext_Query___schema, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + return ec.IntrospectSchema() }, nil, - ec.marshalNStake2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeᚄ, - true, + ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema, true, + false, ) } -func (ec *executionContext) fieldContext_StakeConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeConnection", + Object: "Query", Field: field, - IsMethod: false, + IsMethod: true, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "tokenId": - return ec.fieldContext_Stake_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Stake_tokenDID(ctx, field) - case "owner": - return ec.fieldContext_Stake_owner(ctx, field) - case "level": - return ec.fieldContext_Stake_level(ctx, field) - case "points": - return ec.fieldContext_Stake_points(ctx, field) - case "amount": - return ec.fieldContext_Stake_amount(ctx, field) - case "stakedAt": - return ec.fieldContext_Stake_stakedAt(ctx, field) - case "endsAt": - return ec.fieldContext_Stake_endsAt(ctx, field) - case "withdrawnAt": - return ec.fieldContext_Stake_withdrawnAt(ctx, field) - case "vehicle": - return ec.fieldContext_Stake_vehicle(ctx, field) + case "description": + return ec.fieldContext___Schema_description(ctx, field) + case "types": + return ec.fieldContext___Schema_types(ctx, field) + case "queryType": + return ec.fieldContext___Schema_queryType(ctx, field) + case "mutationType": + return ec.fieldContext___Schema_mutationType(ctx, field) + case "subscriptionType": + return ec.fieldContext___Schema_subscriptionType(ctx, field) + case "directives": + return ec.fieldContext___Schema_directives(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) + return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name) }, } return fc, nil } -func (ec *executionContext) _StakeConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURI_uri(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURI) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StakeConnection_pageInfo, + ec.fieldContext_RedirectURI_uri, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + return obj.URI, nil }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_StakeConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURI_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeConnection", + Object: "RedirectURI", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _StakeEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.StakeEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURI_enabledAt(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURI) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StakeEdge_node, + ec.fieldContext_RedirectURI_enabledAt, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.EnabledAt, nil }, nil, - ec.marshalNStake2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStake, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_StakeEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURI_enabledAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeEdge", + Object: "RedirectURI", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "tokenId": - return ec.fieldContext_Stake_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Stake_tokenDID(ctx, field) - case "owner": - return ec.fieldContext_Stake_owner(ctx, field) - case "level": - return ec.fieldContext_Stake_level(ctx, field) - case "points": - return ec.fieldContext_Stake_points(ctx, field) - case "amount": - return ec.fieldContext_Stake_amount(ctx, field) - case "stakedAt": - return ec.fieldContext_Stake_stakedAt(ctx, field) - case "endsAt": - return ec.fieldContext_Stake_endsAt(ctx, field) - case "withdrawnAt": - return ec.fieldContext_Stake_withdrawnAt(ctx, field) - case "vehicle": - return ec.fieldContext_Stake_vehicle(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _StakeEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.StakeEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StakeEdge_cursor, + ec.fieldContext_RedirectURIConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.TotalCount, nil }, nil, - ec.marshalNString2string, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_StakeEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StakeEdge", + Object: "RedirectURIConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _StorageNode_label(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_label, + ec.fieldContext_RedirectURIConnection_edges, func(ctx context.Context) (any, error) { - return obj.Label, nil + return obj.Edges, nil }, nil, - ec.marshalNString2string, + ec.marshalNRedirectURIEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURIEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_label(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "RedirectURIConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_RedirectURIEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_RedirectURIEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type RedirectURIEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _StorageNode_address(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_address, + ec.fieldContext_RedirectURIConnection_nodes, func(ctx context.Context) (any, error) { - return obj.Address, nil + return obj.Nodes, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNRedirectURI2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURIᚄ, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "RedirectURIConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "uri": + return ec.fieldContext_RedirectURI_uri(ctx, field) + case "enabledAt": + return ec.fieldContext_RedirectURI_enabledAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type RedirectURI", field.Name) }, } return fc, nil } -func (ec *executionContext) _StorageNode_owner(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_owner, + ec.fieldContext_RedirectURIConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.Owner, nil + return obj.PageInfo, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "RedirectURIConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _StorageNode_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_tokenId, + ec.fieldContext_RedirectURIEdge_node, func(ctx context.Context) (any, error) { - return obj.TokenID, nil + return obj.Node, nil }, nil, - ec.marshalNBigInt2ᚖmathᚋbigᚐInt, + ec.marshalNRedirectURI2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐRedirectURI, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "RedirectURIEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type BigInt does not have child fields") + switch field.Name { + case "uri": + return ec.fieldContext_RedirectURI_uri(ctx, field) + case "enabledAt": + return ec.fieldContext_RedirectURI_enabledAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type RedirectURI", field.Name) }, } return fc, nil } -func (ec *executionContext) _StorageNode_uri(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _RedirectURIEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.RedirectURIEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_uri, + ec.fieldContext_RedirectURIEdge_cursor, func(ctx context.Context) (any, error) { - return obj.URI, nil + return obj.Cursor, nil }, nil, ec.marshalNString2string, @@ -10800,9 +11441,9 @@ func (ec *executionContext) _StorageNode_uri(ctx context.Context, field graphql. ) } -func (ec *executionContext) fieldContext_StorageNode_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_RedirectURIEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "RedirectURIEdge", Field: field, IsMethod: false, IsResolver: false, @@ -10813,188 +11454,202 @@ func (ec *executionContext) fieldContext_StorageNode_uri(_ context.Context, fiel return fc, nil } -func (ec *executionContext) _StorageNode_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_grantee(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_tokenDID, + ec.fieldContext_Sacd_grantee, func(ctx context.Context) (any, error) { - return obj.TokenDID, nil + return obj.Grantee, nil }, nil, - ec.marshalNString2string, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_grantee(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _StorageNode_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_permissions(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_StorageNode_mintedAt, + ec.fieldContext_Sacd_permissions, func(ctx context.Context) (any, error) { - return obj.MintedAt, nil + return obj.Permissions, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_StorageNode_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_permissions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "StorageNode", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_id(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_source(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_id, + ec.fieldContext_Sacd_source, func(ctx context.Context) (any, error) { - return obj.ID, nil + return obj.Source, nil }, nil, - ec.marshalNID2string, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_source(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ID does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_name(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_name, + ec.fieldContext_Sacd_createdAt, func(ctx context.Context) (any, error) { - return obj.Name, nil + return obj.CreatedAt, nil }, nil, - ec.marshalNString2string, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_expiresAt(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_tokenId, + ec.fieldContext_Sacd_expiresAt, func(ctx context.Context) (any, error) { - return obj.TokenID, nil + return obj.ExpiresAt, nil }, nil, - ec.marshalNInt2int, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _Sacd_template(ctx context.Context, field graphql.CollectedField, obj *model.Sacd) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_tokenDID, + ec.fieldContext_Sacd_template, func(ctx context.Context) (any, error) { - return obj.TokenDID, nil + return obj.Template, nil }, nil, - ec.marshalNString2string, - true, + ec.marshalOTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, true, + false, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Sacd_template(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "Sacd", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "tokenId": + return ec.fieldContext_Template_tokenId(ctx, field) + case "creator": + return ec.fieldContext_Template_creator(ctx, field) + case "asset": + return ec.fieldContext_Template_asset(ctx, field) + case "permissions": + return ec.fieldContext_Template_permissions(ctx, field) + case "cid": + return ec.fieldContext_Template_cid(ctx, field) + case "createdAt": + return ec.fieldContext_Template_createdAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_integrationId(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_integrationId, + ec.fieldContext_SacdConnection_totalCount, func(ctx context.Context) (any, error) { - return ec.Resolvers.SyntheticDevice().IntegrationID(ctx, obj) + return obj.TotalCount, nil }, nil, ec.marshalNInt2int, @@ -11003,12 +11658,12 @@ func (ec *executionContext) _SyntheticDevice_integrationId(ctx context.Context, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_integrationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "SacdConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return nil, errors.New("field of type Int does not have child fields") }, @@ -11016,532 +11671,492 @@ func (ec *executionContext) fieldContext_SyntheticDevice_integrationId(_ context return fc, nil } -func (ec *executionContext) _SyntheticDevice_address(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_address, + ec.fieldContext_SacdConnection_edges, func(ctx context.Context) (any, error) { - return obj.Address, nil + return obj.Edges, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNSacdEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "SacdConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_SacdEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_SacdEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type SacdEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_mintedAt, + ec.fieldContext_SacdConnection_nodes, func(ctx context.Context) (any, error) { - return obj.MintedAt, nil + return obj.Nodes, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNSacd2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdᚄ, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "SacdConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + switch field.Name { + case "grantee": + return ec.fieldContext_Sacd_grantee(ctx, field) + case "permissions": + return ec.fieldContext_Sacd_permissions(ctx, field) + case "source": + return ec.fieldContext_Sacd_source(ctx, field) + case "createdAt": + return ec.fieldContext_Sacd_createdAt(ctx, field) + case "expiresAt": + return ec.fieldContext_Sacd_expiresAt(ctx, field) + case "template": + return ec.fieldContext_Sacd_template(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_vehicle(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SacdConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_vehicle, + ec.fieldContext_SacdConnection_pageInfo, func(ctx context.Context) (any, error) { - return ec.Resolvers.SyntheticDevice().Vehicle(ctx, obj) + return obj.PageInfo, nil }, nil, - ec.marshalNVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_vehicle(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "SacdConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_Vehicle_id(ctx, field) - case "tokenId": - return ec.fieldContext_Vehicle_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Vehicle_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_Vehicle_manufacturer(ctx, field) - case "owner": - return ec.fieldContext_Vehicle_owner(ctx, field) - case "mintedAt": - return ec.fieldContext_Vehicle_mintedAt(ctx, field) - case "aftermarketDevice": - return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) - case "privileges": - return ec.fieldContext_Vehicle_privileges(ctx, field) - case "sacds": - return ec.fieldContext_Vehicle_sacds(ctx, field) - case "sacd": - return ec.fieldContext_Vehicle_sacd(ctx, field) - case "syntheticDevice": - return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) - case "definition": - return ec.fieldContext_Vehicle_definition(ctx, field) - case "dcn": - return ec.fieldContext_Vehicle_dcn(ctx, field) - case "name": - return ec.fieldContext_Vehicle_name(ctx, field) - case "imageURI": - return ec.fieldContext_Vehicle_imageURI(ctx, field) - case "image": - return ec.fieldContext_Vehicle_image(ctx, field) - case "earnings": - return ec.fieldContext_Vehicle_earnings(ctx, field) - case "dataURI": - return ec.fieldContext_Vehicle_dataURI(ctx, field) - case "stake": - return ec.fieldContext_Vehicle_stake(ctx, field) - case "storageNode": - return ec.fieldContext_Vehicle_storageNode(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDevice_connection(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SacdEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDevice_connection, + ec.fieldContext_SacdEdge_node, func(ctx context.Context) (any, error) { - return ec.Resolvers.SyntheticDevice().Connection(ctx, obj) + return obj.Node, nil }, nil, - ec.marshalNConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnection, + ec.marshalNSacd2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacd, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDevice_connection(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDevice", + Object: "SacdEdge", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext_Connection_name(ctx, field) - case "address": - return ec.fieldContext_Connection_address(ctx, field) - case "owner": - return ec.fieldContext_Connection_owner(ctx, field) - case "tokenId": - return ec.fieldContext_Connection_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Connection_tokenDID(ctx, field) - case "mintedAt": - return ec.fieldContext_Connection_mintedAt(ctx, field) + case "grantee": + return ec.fieldContext_Sacd_grantee(ctx, field) + case "permissions": + return ec.fieldContext_Sacd_permissions(ctx, field) + case "source": + return ec.fieldContext_Sacd_source(ctx, field) + case "createdAt": + return ec.fieldContext_Sacd_createdAt(ctx, field) + case "expiresAt": + return ec.fieldContext_Sacd_expiresAt(ctx, field) + case "template": + return ec.fieldContext_Sacd_template(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Connection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SacdEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SacdEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceConnection_totalCount, + ec.fieldContext_SacdEdge_cursor, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + return obj.Cursor, nil }, nil, - ec.marshalNInt2int, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SacdEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceConnection", + Object: "SacdEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Signer_address(ctx context.Context, field graphql.CollectedField, obj *model.Signer) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceConnection_edges, + ec.fieldContext_Signer_address, func(ctx context.Context) (any, error) { - return obj.Edges, nil + return obj.Address, nil }, nil, - ec.marshalNSyntheticDeviceEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceEdgeᚄ, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Signer_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceConnection", + Object: "Signer", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "cursor": - return ec.fieldContext_SyntheticDeviceEdge_cursor(ctx, field) - case "node": - return ec.fieldContext_SyntheticDeviceEdge_node(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDeviceEdge", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Signer_enabledAt(ctx context.Context, field graphql.CollectedField, obj *model.Signer) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceConnection_nodes, + ec.fieldContext_Signer_enabledAt, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + return obj.EnabledAt, nil }, nil, - ec.marshalNSyntheticDevice2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceᚄ, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Signer_enabledAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceConnection", + Object: "Signer", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_SyntheticDevice_id(ctx, field) - case "name": - return ec.fieldContext_SyntheticDevice_name(ctx, field) - case "tokenId": - return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) - case "integrationId": - return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) - case "address": - return ec.fieldContext_SyntheticDevice_address(ctx, field) - case "mintedAt": - return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) - case "vehicle": - return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) - case "connection": - return ec.fieldContext_SyntheticDevice_connection(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceConnection_pageInfo, + ec.fieldContext_SignerConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + return obj.TotalCount, nil }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceConnection", + Object: "SignerConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceEdge_cursor, + ec.fieldContext_SignerConnection_edges, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.Edges, nil }, nil, - ec.marshalNString2string, + ec.marshalNSignerEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSignerEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceEdge", + Object: "SignerConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_SignerEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_SignerEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type SignerEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _SyntheticDeviceEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_SyntheticDeviceEdge_node, + ec.fieldContext_SignerConnection_nodes, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.Nodes, nil }, nil, - ec.marshalNSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, + ec.marshalNSigner2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSignerᚄ, true, true, ) } -func (ec *executionContext) fieldContext_SyntheticDeviceEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "SyntheticDeviceEdge", + Object: "SignerConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_SyntheticDevice_id(ctx, field) - case "name": - return ec.fieldContext_SyntheticDevice_name(ctx, field) - case "tokenId": - return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) - case "integrationId": - return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) case "address": - return ec.fieldContext_SyntheticDevice_address(ctx, field) - case "mintedAt": - return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) - case "vehicle": - return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) - case "connection": - return ec.fieldContext_SyntheticDevice_connection(ctx, field) + return ec.fieldContext_Signer_address(ctx, field) + case "enabledAt": + return ec.fieldContext_Signer_enabledAt(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Signer", field.Name) }, } return fc, nil } -func (ec *executionContext) _Template_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SignerConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_tokenId, + ec.fieldContext_SignerConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.TokenID, nil + return obj.PageInfo, nil }, nil, - ec.marshalNBigInt2ᚖmathᚋbigᚐInt, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_Template_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "SignerConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type BigInt does not have child fields") + switch field.Name { + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _Template_creator(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SignerEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_creator, + ec.fieldContext_SignerEdge_node, func(ctx context.Context) (any, error) { - return obj.Creator, nil + return obj.Node, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNSigner2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSigner, true, true, ) } -func (ec *executionContext) fieldContext_Template_creator(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "SignerEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + switch field.Name { + case "address": + return ec.fieldContext_Signer_address(ctx, field) + case "enabledAt": + return ec.fieldContext_Signer_enabledAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Signer", field.Name) }, } return fc, nil } -func (ec *executionContext) _Template_asset(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _SignerEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SignerEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_asset, + ec.fieldContext_SignerEdge_cursor, func(ctx context.Context) (any, error) { - return obj.Asset, nil + return obj.Cursor, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_Template_asset(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SignerEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "SignerEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Template_permissions(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_permissions, + ec.fieldContext_Stake_tokenId, func(ctx context.Context) (any, error) { - return obj.Permissions, nil + return obj.TokenID, nil }, nil, - ec.marshalNString2string, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_Template_permissions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Template_cid(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_cid, + ec.fieldContext_Stake_tokenDID, func(ctx context.Context) (any, error) { - return obj.Cid, nil + return obj.TokenDID, nil }, nil, ec.marshalNString2string, @@ -11550,9 +12165,9 @@ func (ec *executionContext) _Template_cid(ctx context.Context, field graphql.Col ) } -func (ec *executionContext) fieldContext_Template_cid(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, @@ -11563,43 +12178,43 @@ func (ec *executionContext) fieldContext_Template_cid(_ context.Context, field g return fc, nil } -func (ec *executionContext) _Template_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_owner(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Template_createdAt, + ec.fieldContext_Stake_owner, func(ctx context.Context) (any, error) { - return obj.CreatedAt, nil + return obj.Owner, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_Template_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Template", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _TemplateConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_level(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateConnection_totalCount, + ec.fieldContext_Stake_level, func(ctx context.Context) (any, error) { - return obj.TotalCount, nil + return obj.Level, nil }, nil, ec.marshalNInt2int, @@ -11608,9 +12223,9 @@ func (ec *executionContext) _TemplateConnection_totalCount(ctx context.Context, ) } -func (ec *executionContext) fieldContext_TemplateConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_level(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateConnection", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, @@ -11621,836 +12236,694 @@ func (ec *executionContext) fieldContext_TemplateConnection_totalCount(_ context return fc, nil } -func (ec *executionContext) _TemplateConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_points(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateConnection_edges, + ec.fieldContext_Stake_points, func(ctx context.Context) (any, error) { - return obj.Edges, nil + return obj.Points, nil }, nil, - ec.marshalNTemplateEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateEdgeᚄ, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_TemplateConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_points(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateConnection", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "node": - return ec.fieldContext_TemplateEdge_node(ctx, field) - case "cursor": - return ec.fieldContext_TemplateEdge_cursor(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type TemplateEdge", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _TemplateConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_amount(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateConnection_nodes, + ec.fieldContext_Stake_amount, func(ctx context.Context) (any, error) { - return obj.Nodes, nil + return obj.Amount, nil }, nil, - ec.marshalNTemplate2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateᚄ, + ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, true, true, ) } -func (ec *executionContext) fieldContext_TemplateConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_amount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateConnection", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "tokenId": - return ec.fieldContext_Template_tokenId(ctx, field) - case "creator": - return ec.fieldContext_Template_creator(ctx, field) - case "asset": - return ec.fieldContext_Template_asset(ctx, field) - case "permissions": - return ec.fieldContext_Template_permissions(ctx, field) - case "cid": - return ec.fieldContext_Template_cid(ctx, field) - case "createdAt": - return ec.fieldContext_Template_createdAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + return nil, errors.New("field of type BigDecimal does not have child fields") }, } return fc, nil } -func (ec *executionContext) _TemplateConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_stakedAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateConnection_pageInfo, + ec.fieldContext_Stake_stakedAt, func(ctx context.Context) (any, error) { - return obj.PageInfo, nil + return obj.StakedAt, nil }, nil, - ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_TemplateConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_stakedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateConnection", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "startCursor": - return ec.fieldContext_PageInfo_startCursor(ctx, field) - case "endCursor": - return ec.fieldContext_PageInfo_endCursor(ctx, field) - case "hasPreviousPage": - return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) - case "hasNextPage": - return ec.fieldContext_PageInfo_hasNextPage(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _TemplateEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.TemplateEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_endsAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateEdge_node, + ec.fieldContext_Stake_endsAt, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.EndsAt, nil }, nil, - ec.marshalNTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_TemplateEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_endsAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateEdge", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "tokenId": - return ec.fieldContext_Template_tokenId(ctx, field) - case "creator": - return ec.fieldContext_Template_creator(ctx, field) - case "asset": - return ec.fieldContext_Template_asset(ctx, field) - case "permissions": - return ec.fieldContext_Template_permissions(ctx, field) - case "cid": - return ec.fieldContext_Template_cid(ctx, field) - case "createdAt": - return ec.fieldContext_Template_createdAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _TemplateEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.TemplateEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_withdrawnAt(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_TemplateEdge_cursor, + ec.fieldContext_Stake_withdrawnAt, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.WithdrawnAt, nil }, nil, - ec.marshalNString2string, - true, + ec.marshalOTime2ᚖtimeᚐTime, true, + false, ) } -func (ec *executionContext) fieldContext_TemplateEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_withdrawnAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "TemplateEdge", + Object: "Stake", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _UserRewards_totalTokens(ctx context.Context, field graphql.CollectedField, obj *model.UserRewards) (ret graphql.Marshaler) { +func (ec *executionContext) _Stake_vehicle(ctx context.Context, field graphql.CollectedField, obj *model.Stake) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UserRewards_totalTokens, + ec.fieldContext_Stake_vehicle, func(ctx context.Context) (any, error) { - return obj.TotalTokens, nil + return ec.Resolvers.Stake().Vehicle(ctx, obj) }, nil, - ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, - true, + ec.marshalOVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, true, + false, ) } -func (ec *executionContext) fieldContext_UserRewards_totalTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Stake_vehicle(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UserRewards", + Object: "Stake", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type BigDecimal does not have child fields") + switch field.Name { + case "id": + return ec.fieldContext_Vehicle_id(ctx, field) + case "tokenId": + return ec.fieldContext_Vehicle_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Vehicle_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_Vehicle_manufacturer(ctx, field) + case "owner": + return ec.fieldContext_Vehicle_owner(ctx, field) + case "mintedAt": + return ec.fieldContext_Vehicle_mintedAt(ctx, field) + case "aftermarketDevice": + return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) + case "privileges": + return ec.fieldContext_Vehicle_privileges(ctx, field) + case "sacds": + return ec.fieldContext_Vehicle_sacds(ctx, field) + case "sacd": + return ec.fieldContext_Vehicle_sacd(ctx, field) + case "syntheticDevice": + return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) + case "definition": + return ec.fieldContext_Vehicle_definition(ctx, field) + case "dcn": + return ec.fieldContext_Vehicle_dcn(ctx, field) + case "name": + return ec.fieldContext_Vehicle_name(ctx, field) + case "imageURI": + return ec.fieldContext_Vehicle_imageURI(ctx, field) + case "image": + return ec.fieldContext_Vehicle_image(ctx, field) + case "earnings": + return ec.fieldContext_Vehicle_earnings(ctx, field) + case "dataURI": + return ec.fieldContext_Vehicle_dataURI(ctx, field) + case "stake": + return ec.fieldContext_Vehicle_stake(ctx, field) + case "storageNode": + return ec.fieldContext_Vehicle_storageNode(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) }, } return fc, nil } -func (ec *executionContext) _UserRewards_history(ctx context.Context, field graphql.CollectedField, obj *model.UserRewards) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UserRewards_history, + ec.fieldContext_StakeConnection_totalCount, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.UserRewards().History(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + return obj.TotalCount, nil }, nil, - ec.marshalNEarningsConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐEarningsConnection, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_UserRewards_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UserRewards", + Object: "StakeConnection", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_EarningsConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_EarningsConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_EarningsConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_EarningsConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type EarningsConnection", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_UserRewards_history_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Vehicle_id(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_id, + ec.fieldContext_StakeConnection_edges, func(ctx context.Context) (any, error) { - return obj.ID, nil + return obj.Edges, nil }, nil, - ec.marshalNID2string, + ec.marshalNStakeEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StakeConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ID does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_StakeEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_StakeEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type StakeEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _Vehicle_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_tokenId, + ec.fieldContext_StakeConnection_nodes, func(ctx context.Context) (any, error) { - return obj.TokenID, nil + return obj.Nodes, nil }, nil, - ec.marshalNInt2int, + ec.marshalNStake2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStakeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StakeConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + switch field.Name { + case "tokenId": + return ec.fieldContext_Stake_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Stake_tokenDID(ctx, field) + case "owner": + return ec.fieldContext_Stake_owner(ctx, field) + case "level": + return ec.fieldContext_Stake_level(ctx, field) + case "points": + return ec.fieldContext_Stake_points(ctx, field) + case "amount": + return ec.fieldContext_Stake_amount(ctx, field) + case "stakedAt": + return ec.fieldContext_Stake_stakedAt(ctx, field) + case "endsAt": + return ec.fieldContext_Stake_endsAt(ctx, field) + case "withdrawnAt": + return ec.fieldContext_Stake_withdrawnAt(ctx, field) + case "vehicle": + return ec.fieldContext_Stake_vehicle(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) }, } return fc, nil } -func (ec *executionContext) _Vehicle_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.StakeConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_tokenDID, + ec.fieldContext_StakeConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.TokenDID, nil + return obj.PageInfo, nil }, nil, - ec.marshalNString2string, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StakeConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _Vehicle_manufacturer(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.StakeEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_manufacturer, + ec.fieldContext_StakeEdge_node, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().Manufacturer(ctx, obj) + return obj.Node, nil }, nil, - ec.marshalNManufacturer2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturer, + ec.marshalNStake2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStake, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_manufacturer(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StakeEdge", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_Manufacturer_id(ctx, field) case "tokenId": - return ec.fieldContext_Manufacturer_tokenId(ctx, field) + return ec.fieldContext_Stake_tokenId(ctx, field) case "tokenDID": - return ec.fieldContext_Manufacturer_tokenDID(ctx, field) - case "name": - return ec.fieldContext_Manufacturer_name(ctx, field) + return ec.fieldContext_Stake_tokenDID(ctx, field) case "owner": - return ec.fieldContext_Manufacturer_owner(ctx, field) - case "tableId": - return ec.fieldContext_Manufacturer_tableId(ctx, field) - case "mintedAt": - return ec.fieldContext_Manufacturer_mintedAt(ctx, field) - case "aftermarketDevices": - return ec.fieldContext_Manufacturer_aftermarketDevices(ctx, field) - case "deviceDefinitions": - return ec.fieldContext_Manufacturer_deviceDefinitions(ctx, field) + return ec.fieldContext_Stake_owner(ctx, field) + case "level": + return ec.fieldContext_Stake_level(ctx, field) + case "points": + return ec.fieldContext_Stake_points(ctx, field) + case "amount": + return ec.fieldContext_Stake_amount(ctx, field) + case "stakedAt": + return ec.fieldContext_Stake_stakedAt(ctx, field) + case "endsAt": + return ec.fieldContext_Stake_endsAt(ctx, field) + case "withdrawnAt": + return ec.fieldContext_Stake_withdrawnAt(ctx, field) + case "vehicle": + return ec.fieldContext_Stake_vehicle(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Manufacturer", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) }, } return fc, nil } -func (ec *executionContext) _Vehicle_owner(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StakeEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.StakeEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_owner, + ec.fieldContext_StakeEdge_cursor, func(ctx context.Context) (any, error) { - return obj.Owner, nil + return obj.Cursor, nil }, nil, - ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StakeEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StakeEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Address does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_label(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_mintedAt, + ec.fieldContext_StorageNode_label, func(ctx context.Context) (any, error) { - return obj.MintedAt, nil + return obj.Label, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_label(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_aftermarketDevice(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_address(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_aftermarketDevice, + ec.fieldContext_StorageNode_address, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().AftermarketDevice(ctx, obj) + return obj.Address, nil }, nil, - ec.marshalOAftermarketDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDevice, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_aftermarketDevice(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_AftermarketDevice_id(ctx, field) - case "tokenId": - return ec.fieldContext_AftermarketDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_AftermarketDevice_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_AftermarketDevice_manufacturer(ctx, field) - case "address": - return ec.fieldContext_AftermarketDevice_address(ctx, field) - case "owner": - return ec.fieldContext_AftermarketDevice_owner(ctx, field) - case "serial": - return ec.fieldContext_AftermarketDevice_serial(ctx, field) - case "imei": - return ec.fieldContext_AftermarketDevice_imei(ctx, field) - case "devEUI": - return ec.fieldContext_AftermarketDevice_devEUI(ctx, field) - case "hardwareRevision": - return ec.fieldContext_AftermarketDevice_hardwareRevision(ctx, field) - case "mintedAt": - return ec.fieldContext_AftermarketDevice_mintedAt(ctx, field) - case "claimedAt": - return ec.fieldContext_AftermarketDevice_claimedAt(ctx, field) - case "vehicle": - return ec.fieldContext_AftermarketDevice_vehicle(ctx, field) - case "beneficiary": - return ec.fieldContext_AftermarketDevice_beneficiary(ctx, field) - case "name": - return ec.fieldContext_AftermarketDevice_name(ctx, field) - case "image": - return ec.fieldContext_AftermarketDevice_image(ctx, field) - case "earnings": - return ec.fieldContext_AftermarketDevice_earnings(ctx, field) - case "pairedAt": - return ec.fieldContext_AftermarketDevice_pairedAt(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type AftermarketDevice", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_privileges(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_owner(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_privileges, + ec.fieldContext_StorageNode_owner, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Vehicle().Privileges(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.PrivilegeFilterBy)) + return obj.Owner, nil }, nil, - ec.marshalNPrivilegesConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegesConnection, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_privileges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_PrivilegesConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_PrivilegesConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_PrivilegesConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_PrivilegesConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PrivilegesConnection", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Vehicle_privileges_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Vehicle_sacds(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_sacds, + ec.fieldContext_StorageNode_tokenId, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Vehicle().Sacds(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + return obj.TokenID, nil }, nil, - ec.marshalNSacdConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdConnection, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_sacds(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_SacdConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_SacdConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_SacdConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_SacdConnection_pageInfo(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SacdConnection", field.Name) + return nil, errors.New("field of type BigInt does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Vehicle_sacds_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Vehicle_sacd(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_uri(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_sacd, + ec.fieldContext_StorageNode_uri, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.Vehicle().Sacd(ctx, obj, fc.Args["grantee"].(common.Address)) + return obj.URI, nil }, nil, - ec.marshalOSacd2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacd, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_sacd(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_uri(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "grantee": - return ec.fieldContext_Sacd_grantee(ctx, field) - case "permissions": - return ec.fieldContext_Sacd_permissions(ctx, field) - case "source": - return ec.fieldContext_Sacd_source(ctx, field) - case "createdAt": - return ec.fieldContext_Sacd_createdAt(ctx, field) - case "expiresAt": - return ec.fieldContext_Sacd_expiresAt(ctx, field) - case "template": - return ec.fieldContext_Sacd_template(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Vehicle_sacd_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _Vehicle_syntheticDevice(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_syntheticDevice, + ec.fieldContext_StorageNode_tokenDID, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().SyntheticDevice(ctx, obj) + return obj.TokenDID, nil }, nil, - ec.marshalOSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_syntheticDevice(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_SyntheticDevice_id(ctx, field) - case "name": - return ec.fieldContext_SyntheticDevice_name(ctx, field) - case "tokenId": - return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) - case "integrationId": - return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) - case "address": - return ec.fieldContext_SyntheticDevice_address(ctx, field) - case "mintedAt": - return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) - case "vehicle": - return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) - case "connection": - return ec.fieldContext_SyntheticDevice_connection(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_definition(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _StorageNode_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.StorageNode) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_definition, + ec.fieldContext_StorageNode_mintedAt, func(ctx context.Context) (any, error) { - return obj.Definition, nil + return obj.MintedAt, nil }, nil, - ec.marshalODefinition2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDefinition, + ec.marshalNTime2timeᚐTime, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_definition(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_StorageNode_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "StorageNode", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Definition_id(ctx, field) - case "make": - return ec.fieldContext_Definition_make(ctx, field) - case "model": - return ec.fieldContext_Definition_model(ctx, field) - case "year": - return ec.fieldContext_Definition_year(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Definition", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_dcn(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_id(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_dcn, + ec.fieldContext_SyntheticDevice_id, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().Dcn(ctx, obj) + return obj.ID, nil }, nil, - ec.marshalODCN2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDcn, + ec.marshalNID2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_dcn(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_DCN_id(ctx, field) - case "node": - return ec.fieldContext_DCN_node(ctx, field) - case "tokenId": - return ec.fieldContext_DCN_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_DCN_tokenDID(ctx, field) - case "owner": - return ec.fieldContext_DCN_owner(ctx, field) - case "expiresAt": - return ec.fieldContext_DCN_expiresAt(ctx, field) - case "mintedAt": - return ec.fieldContext_DCN_mintedAt(ctx, field) - case "name": - return ec.fieldContext_DCN_name(ctx, field) - case "vehicle": - return ec.fieldContext_DCN_vehicle(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type DCN", field.Name) + return nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_name(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_name(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_name, + ec.fieldContext_SyntheticDevice_name, func(ctx context.Context) (any, error) { return obj.Name, nil }, @@ -12461,9 +12934,9 @@ func (ec *executionContext) _Vehicle_name(ctx context.Context, field graphql.Col ) } -func (ec *executionContext) fieldContext_Vehicle_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: false, IsResolver: false, @@ -12474,43 +12947,43 @@ func (ec *executionContext) fieldContext_Vehicle_name(_ context.Context, field g return fc, nil } -func (ec *executionContext) _Vehicle_imageURI(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_imageURI, + ec.fieldContext_SyntheticDevice_tokenId, func(ctx context.Context) (any, error) { - return obj.ImageURI, nil + return obj.TokenID, nil }, nil, - ec.marshalNString2string, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_imageURI(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_image(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_image, + ec.fieldContext_SyntheticDevice_tokenDID, func(ctx context.Context) (any, error) { - return obj.Image, nil + return obj.TokenDID, nil }, nil, ec.marshalNString2string, @@ -12519,9 +12992,9 @@ func (ec *executionContext) _Vehicle_image(ctx context.Context, field graphql.Co ) } -func (ec *executionContext) fieldContext_Vehicle_image(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: false, IsResolver: false, @@ -12532,172 +13005,213 @@ func (ec *executionContext) fieldContext_Vehicle_image(_ context.Context, field return fc, nil } -func (ec *executionContext) _Vehicle_earnings(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_integrationId(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_earnings, + ec.fieldContext_SyntheticDevice_integrationId, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().Earnings(ctx, obj) + return ec.Resolvers.SyntheticDevice().IntegrationID(ctx, obj) }, nil, - ec.marshalOVehicleEarnings2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleEarnings, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_earnings(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_integrationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: true, IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalTokens": - return ec.fieldContext_VehicleEarnings_totalTokens(ctx, field) - case "history": - return ec.fieldContext_VehicleEarnings_history(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type VehicleEarnings", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_dataURI(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_address(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_dataURI, + ec.fieldContext_SyntheticDevice_address, func(ctx context.Context) (any, error) { - return obj.DataURI, nil + return obj.Address, nil }, nil, - ec.marshalNString2string, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_Vehicle_dataURI(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_address(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Vehicle_stake(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_stake, + ec.fieldContext_SyntheticDevice_mintedAt, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().Stake(ctx, obj) + return obj.MintedAt, nil }, nil, - ec.marshalOStake2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStake, + ec.marshalNTime2timeᚐTime, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_stake(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _SyntheticDevice_vehicle(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_SyntheticDevice_vehicle, + func(ctx context.Context) (any, error) { + return ec.Resolvers.SyntheticDevice().Vehicle(ctx, obj) + }, + nil, + ec.marshalNVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_SyntheticDevice_vehicle(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "SyntheticDevice", Field: field, IsMethod: true, IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { + case "id": + return ec.fieldContext_Vehicle_id(ctx, field) case "tokenId": - return ec.fieldContext_Stake_tokenId(ctx, field) + return ec.fieldContext_Vehicle_tokenId(ctx, field) case "tokenDID": - return ec.fieldContext_Stake_tokenDID(ctx, field) + return ec.fieldContext_Vehicle_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_Vehicle_manufacturer(ctx, field) case "owner": - return ec.fieldContext_Stake_owner(ctx, field) - case "level": - return ec.fieldContext_Stake_level(ctx, field) - case "points": - return ec.fieldContext_Stake_points(ctx, field) - case "amount": - return ec.fieldContext_Stake_amount(ctx, field) - case "stakedAt": - return ec.fieldContext_Stake_stakedAt(ctx, field) - case "endsAt": - return ec.fieldContext_Stake_endsAt(ctx, field) - case "withdrawnAt": - return ec.fieldContext_Stake_withdrawnAt(ctx, field) - case "vehicle": - return ec.fieldContext_Stake_vehicle(ctx, field) + return ec.fieldContext_Vehicle_owner(ctx, field) + case "mintedAt": + return ec.fieldContext_Vehicle_mintedAt(ctx, field) + case "aftermarketDevice": + return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) + case "privileges": + return ec.fieldContext_Vehicle_privileges(ctx, field) + case "sacds": + return ec.fieldContext_Vehicle_sacds(ctx, field) + case "sacd": + return ec.fieldContext_Vehicle_sacd(ctx, field) + case "syntheticDevice": + return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) + case "definition": + return ec.fieldContext_Vehicle_definition(ctx, field) + case "dcn": + return ec.fieldContext_Vehicle_dcn(ctx, field) + case "name": + return ec.fieldContext_Vehicle_name(ctx, field) + case "imageURI": + return ec.fieldContext_Vehicle_imageURI(ctx, field) + case "image": + return ec.fieldContext_Vehicle_image(ctx, field) + case "earnings": + return ec.fieldContext_Vehicle_earnings(ctx, field) + case "dataURI": + return ec.fieldContext_Vehicle_dataURI(ctx, field) + case "stake": + return ec.fieldContext_Vehicle_stake(ctx, field) + case "storageNode": + return ec.fieldContext_Vehicle_storageNode(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) }, } return fc, nil } -func (ec *executionContext) _Vehicle_storageNode(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDevice_connection(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDevice) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_Vehicle_storageNode, + ec.fieldContext_SyntheticDevice_connection, func(ctx context.Context) (any, error) { - return ec.Resolvers.Vehicle().StorageNode(ctx, obj) + return ec.Resolvers.SyntheticDevice().Connection(ctx, obj) }, nil, - ec.marshalOStorageNode2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStorageNode, + ec.marshalNConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐConnection, + true, true, - false, ) } -func (ec *executionContext) fieldContext_Vehicle_storageNode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDevice_connection(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Vehicle", + Object: "SyntheticDevice", Field: field, IsMethod: true, IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "label": - return ec.fieldContext_StorageNode_label(ctx, field) + case "name": + return ec.fieldContext_Connection_name(ctx, field) case "address": - return ec.fieldContext_StorageNode_address(ctx, field) + return ec.fieldContext_Connection_address(ctx, field) case "owner": - return ec.fieldContext_StorageNode_owner(ctx, field) + return ec.fieldContext_Connection_owner(ctx, field) case "tokenId": - return ec.fieldContext_StorageNode_tokenId(ctx, field) - case "uri": - return ec.fieldContext_StorageNode_uri(ctx, field) + return ec.fieldContext_Connection_tokenId(ctx, field) case "tokenDID": - return ec.fieldContext_StorageNode_tokenDID(ctx, field) + return ec.fieldContext_Connection_tokenDID(ctx, field) case "mintedAt": - return ec.fieldContext_StorageNode_mintedAt(ctx, field) + return ec.fieldContext_Connection_mintedAt(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type StorageNode", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Connection", field.Name) }, } return fc, nil } -func (ec *executionContext) _VehicleConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleConnection_totalCount, + ec.fieldContext_SyntheticDeviceConnection_totalCount, func(ctx context.Context) (any, error) { return obj.TotalCount, nil }, @@ -12708,9 +13222,9 @@ func (ec *executionContext) _VehicleConnection_totalCount(ctx context.Context, f ) } -func (ec *executionContext) fieldContext_VehicleConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleConnection", + Object: "SyntheticDeviceConnection", Field: field, IsMethod: false, IsResolver: false, @@ -12721,118 +13235,96 @@ func (ec *executionContext) fieldContext_VehicleConnection_totalCount(_ context. return fc, nil } -func (ec *executionContext) _VehicleConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleConnection_edges, + ec.fieldContext_SyntheticDeviceConnection_edges, func(ctx context.Context) (any, error) { return obj.Edges, nil }, nil, - ec.marshalNVehicleEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleEdgeᚄ, + ec.marshalNSyntheticDeviceEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext_VehicleConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleConnection", + Object: "SyntheticDeviceConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "node": - return ec.fieldContext_VehicleEdge_node(ctx, field) case "cursor": - return ec.fieldContext_VehicleEdge_cursor(ctx, field) + return ec.fieldContext_SyntheticDeviceEdge_cursor(ctx, field) + case "node": + return ec.fieldContext_SyntheticDeviceEdge_node(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type VehicleEdge", field.Name) + return nil, fmt.Errorf("no field named %q was found under type SyntheticDeviceEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _VehicleConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleConnection_nodes, + ec.fieldContext_SyntheticDeviceConnection_nodes, func(ctx context.Context) (any, error) { return obj.Nodes, nil }, nil, - ec.marshalNVehicle2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleᚄ, + ec.marshalNSyntheticDevice2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceᚄ, true, true, ) } -func (ec *executionContext) fieldContext_VehicleConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleConnection", + Object: "SyntheticDeviceConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Vehicle_id(ctx, field) + return ec.fieldContext_SyntheticDevice_id(ctx, field) + case "name": + return ec.fieldContext_SyntheticDevice_name(ctx, field) case "tokenId": - return ec.fieldContext_Vehicle_tokenId(ctx, field) + return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) case "tokenDID": - return ec.fieldContext_Vehicle_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_Vehicle_manufacturer(ctx, field) - case "owner": - return ec.fieldContext_Vehicle_owner(ctx, field) + return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) + case "integrationId": + return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) + case "address": + return ec.fieldContext_SyntheticDevice_address(ctx, field) case "mintedAt": - return ec.fieldContext_Vehicle_mintedAt(ctx, field) - case "aftermarketDevice": - return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) - case "privileges": - return ec.fieldContext_Vehicle_privileges(ctx, field) - case "sacds": - return ec.fieldContext_Vehicle_sacds(ctx, field) - case "sacd": - return ec.fieldContext_Vehicle_sacd(ctx, field) - case "syntheticDevice": - return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) - case "definition": - return ec.fieldContext_Vehicle_definition(ctx, field) - case "dcn": - return ec.fieldContext_Vehicle_dcn(ctx, field) - case "name": - return ec.fieldContext_Vehicle_name(ctx, field) - case "imageURI": - return ec.fieldContext_Vehicle_imageURI(ctx, field) - case "image": - return ec.fieldContext_Vehicle_image(ctx, field) - case "earnings": - return ec.fieldContext_Vehicle_earnings(ctx, field) - case "dataURI": - return ec.fieldContext_Vehicle_dataURI(ctx, field) - case "stake": - return ec.fieldContext_Vehicle_stake(ctx, field) - case "storageNode": - return ec.fieldContext_Vehicle_storageNode(ctx, field) + return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) + case "vehicle": + return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) + case "connection": + return ec.fieldContext_SyntheticDevice_connection(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) + return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) }, } return fc, nil } -func (ec *executionContext) _VehicleConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleConnection_pageInfo, + ec.fieldContext_SyntheticDeviceConnection_pageInfo, func(ctx context.Context) (any, error) { return obj.PageInfo, nil }, @@ -12843,9 +13335,9 @@ func (ec *executionContext) _VehicleConnection_pageInfo(ctx context.Context, fie ) } -func (ec *executionContext) fieldContext_VehicleConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleConnection", + Object: "SyntheticDeviceConnection", Field: field, IsMethod: false, IsResolver: false, @@ -12866,236 +13358,192 @@ func (ec *executionContext) fieldContext_VehicleConnection_pageInfo(_ context.Co return fc, nil } -func (ec *executionContext) _VehicleEarnings_totalTokens(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEarnings) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleEarnings_totalTokens, + ec.fieldContext_SyntheticDeviceEdge_cursor, func(ctx context.Context) (any, error) { - return obj.TotalTokens, nil + return obj.Cursor, nil }, nil, - ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_VehicleEarnings_totalTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleEarnings", + Object: "SyntheticDeviceEdge", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type BigDecimal does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _VehicleEarnings_history(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEarnings) (ret graphql.Marshaler) { +func (ec *executionContext) _SyntheticDeviceEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.SyntheticDeviceEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleEarnings_history, + ec.fieldContext_SyntheticDeviceEdge_node, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return ec.Resolvers.VehicleEarnings().History(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + return obj.Node, nil }, nil, - ec.marshalNEarningsConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐEarningsConnection, + ec.marshalNSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, true, true, ) } -func (ec *executionContext) fieldContext_VehicleEarnings_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_SyntheticDeviceEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleEarnings", + Object: "SyntheticDeviceEdge", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "totalCount": - return ec.fieldContext_EarningsConnection_totalCount(ctx, field) - case "edges": - return ec.fieldContext_EarningsConnection_edges(ctx, field) - case "nodes": - return ec.fieldContext_EarningsConnection_nodes(ctx, field) - case "pageInfo": - return ec.fieldContext_EarningsConnection_pageInfo(ctx, field) + case "id": + return ec.fieldContext_SyntheticDevice_id(ctx, field) + case "name": + return ec.fieldContext_SyntheticDevice_name(ctx, field) + case "tokenId": + return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) + case "integrationId": + return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) + case "address": + return ec.fieldContext_SyntheticDevice_address(ctx, field) + case "mintedAt": + return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) + case "vehicle": + return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) + case "connection": + return ec.fieldContext_SyntheticDevice_connection(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type EarningsConnection", field.Name) + return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_VehicleEarnings_history_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) _VehicleEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleEdge_node, + ec.fieldContext_Template_tokenId, func(ctx context.Context) (any, error) { - return obj.Node, nil + return obj.TokenID, nil }, nil, - ec.marshalNVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, + ec.marshalNBigInt2ᚖmathᚋbigᚐInt, true, true, ) } -func (ec *executionContext) fieldContext_VehicleEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleEdge", + Object: "Template", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Vehicle_id(ctx, field) - case "tokenId": - return ec.fieldContext_Vehicle_tokenId(ctx, field) - case "tokenDID": - return ec.fieldContext_Vehicle_tokenDID(ctx, field) - case "manufacturer": - return ec.fieldContext_Vehicle_manufacturer(ctx, field) - case "owner": - return ec.fieldContext_Vehicle_owner(ctx, field) - case "mintedAt": - return ec.fieldContext_Vehicle_mintedAt(ctx, field) - case "aftermarketDevice": - return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) - case "privileges": - return ec.fieldContext_Vehicle_privileges(ctx, field) - case "sacds": - return ec.fieldContext_Vehicle_sacds(ctx, field) - case "sacd": - return ec.fieldContext_Vehicle_sacd(ctx, field) - case "syntheticDevice": - return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) - case "definition": - return ec.fieldContext_Vehicle_definition(ctx, field) - case "dcn": - return ec.fieldContext_Vehicle_dcn(ctx, field) - case "name": - return ec.fieldContext_Vehicle_name(ctx, field) - case "imageURI": - return ec.fieldContext_Vehicle_imageURI(ctx, field) - case "image": - return ec.fieldContext_Vehicle_image(ctx, field) - case "earnings": - return ec.fieldContext_Vehicle_earnings(ctx, field) - case "dataURI": - return ec.fieldContext_Vehicle_dataURI(ctx, field) - case "stake": - return ec.fieldContext_Vehicle_stake(ctx, field) - case "storageNode": - return ec.fieldContext_Vehicle_storageNode(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) + return nil, errors.New("field of type BigInt does not have child fields") }, } return fc, nil } -func (ec *executionContext) _VehicleEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEdge) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_creator(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_VehicleEdge_cursor, + ec.fieldContext_Template_creator, func(ctx context.Context) (any, error) { - return obj.Cursor, nil + return obj.Creator, nil }, nil, - ec.marshalNString2string, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext_VehicleEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_creator(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "VehicleEdge", + Object: "Template", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_asset(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Directive_name, + ec.fieldContext_Template_asset, func(ctx context.Context) (any, error) { - return obj.Name, nil + return obj.Asset, nil }, nil, - ec.marshalNString2string, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext___Directive_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_asset(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Directive", + Object: "Template", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_permissions(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Directive_description, + ec.fieldContext_Template_permissions, func(ctx context.Context) (any, error) { - return obj.Description(), nil + return obj.Permissions, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Directive_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_permissions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Directive", + Object: "Template", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return nil, errors.New("field of type String does not have child fields") @@ -13104,242 +13552,261 @@ func (ec *executionContext) fieldContext___Directive_description(_ context.Conte return fc, nil } -func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_cid(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Directive_isRepeatable, + ec.fieldContext_Template_cid, func(ctx context.Context) (any, error) { - return obj.IsRepeatable, nil + return obj.Cid, nil }, nil, - ec.marshalNBoolean2bool, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext___Directive_isRepeatable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_cid(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Directive", + Object: "Template", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { +func (ec *executionContext) _Template_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.Template) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Directive_locations, + ec.fieldContext_Template_createdAt, func(ctx context.Context) (any, error) { - return obj.Locations, nil + return obj.CreatedAt, nil }, nil, - ec.marshalN__DirectiveLocation2ᚕstringᚄ, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext___Directive_locations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Template_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Directive", + Object: "Template", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type __DirectiveLocation does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Directive_args, + ec.fieldContext_TemplateConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.Args, nil + return obj.TotalCount, nil }, nil, - ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Directive", + Object: "TemplateConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "name": - return ec.fieldContext___InputValue_name(ctx, field) - case "description": - return ec.fieldContext___InputValue_description(ctx, field) - case "type": - return ec.fieldContext___InputValue_type(ctx, field) - case "defaultValue": - return ec.fieldContext___InputValue_defaultValue(ctx, field) - case "isDeprecated": - return ec.fieldContext___InputValue_isDeprecated(ctx, field) - case "deprecationReason": - return ec.fieldContext___InputValue_deprecationReason(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field___Directive_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___EnumValue_name, + ec.fieldContext_TemplateConnection_edges, func(ctx context.Context) (any, error) { - return obj.Name, nil + return obj.Edges, nil }, nil, - ec.marshalNString2string, + ec.marshalNTemplateEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateEdgeᚄ, true, true, ) } -func (ec *executionContext) fieldContext___EnumValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__EnumValue", + Object: "TemplateConnection", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "node": + return ec.fieldContext_TemplateEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_TemplateEdge_cursor(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type TemplateEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___EnumValue_description, + ec.fieldContext_TemplateConnection_nodes, func(ctx context.Context) (any, error) { - return obj.Description(), nil + return obj.Nodes, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNTemplate2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplateᚄ, + true, true, - false, ) } -func (ec *executionContext) fieldContext___EnumValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__EnumValue", + Object: "TemplateConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "tokenId": + return ec.fieldContext_Template_tokenId(ctx, field) + case "creator": + return ec.fieldContext_Template_creator(ctx, field) + case "asset": + return ec.fieldContext_Template_asset(ctx, field) + case "permissions": + return ec.fieldContext_Template_permissions(ctx, field) + case "cid": + return ec.fieldContext_Template_cid(ctx, field) + case "createdAt": + return ec.fieldContext_Template_createdAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) }, } return fc, nil } -func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.TemplateConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___EnumValue_isDeprecated, + ec.fieldContext_TemplateConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.IsDeprecated(), nil + return obj.PageInfo, nil }, nil, - ec.marshalNBoolean2bool, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, true, true, ) } -func (ec *executionContext) fieldContext___EnumValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__EnumValue", + Object: "TemplateConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + switch field.Name { + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.TemplateEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___EnumValue_deprecationReason, + ec.fieldContext_TemplateEdge_node, func(ctx context.Context) (any, error) { - return obj.DeprecationReason(), nil + return obj.Node, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNTemplate2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐTemplate, + true, true, - false, ) } -func (ec *executionContext) fieldContext___EnumValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__EnumValue", + Object: "TemplateEdge", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "tokenId": + return ec.fieldContext_Template_tokenId(ctx, field) + case "creator": + return ec.fieldContext_Template_creator(ctx, field) + case "asset": + return ec.fieldContext_Template_asset(ctx, field) + case "permissions": + return ec.fieldContext_Template_permissions(ctx, field) + case "cid": + return ec.fieldContext_Template_cid(ctx, field) + case "createdAt": + return ec.fieldContext_Template_createdAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _TemplateEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.TemplateEdge) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_name, + ec.fieldContext_TemplateEdge_cursor, func(ctx context.Context) (any, error) { - return obj.Name, nil + return obj.Cursor, nil }, nil, ec.marshalNString2string, @@ -13348,9 +13815,9 @@ func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.Col ) } -func (ec *executionContext) fieldContext___Field_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_TemplateEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "TemplateEdge", Field: field, IsMethod: false, IsResolver: false, @@ -13361,73 +13828,70 @@ func (ec *executionContext) fieldContext___Field_name(_ context.Context, field g return fc, nil } -func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _UserRewards_totalTokens(ctx context.Context, field graphql.CollectedField, obj *model.UserRewards) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_description, + ec.fieldContext_UserRewards_totalTokens, func(ctx context.Context) (any, error) { - return obj.Description(), nil + return obj.TotalTokens, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Field_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_UserRewards_totalTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "UserRewards", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type BigDecimal does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _UserRewards_history(ctx context.Context, field graphql.CollectedField, obj *model.UserRewards) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_args, + ec.fieldContext_UserRewards_history, func(ctx context.Context) (any, error) { - return obj.Args, nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.UserRewards().History(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + ec.marshalNEarningsConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐEarningsConnection, true, true, ) } -func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_UserRewards_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "UserRewards", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext___InputValue_name(ctx, field) - case "description": - return ec.fieldContext___InputValue_description(ctx, field) - case "type": - return ec.fieldContext___InputValue_type(ctx, field) - case "defaultValue": - return ec.fieldContext___InputValue_defaultValue(ctx, field) - case "isDeprecated": - return ec.fieldContext___InputValue_isDeprecated(ctx, field) - case "deprecationReason": - return ec.fieldContext___InputValue_deprecationReason(ctx, field) + case "totalCount": + return ec.fieldContext_EarningsConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_EarningsConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_EarningsConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_EarningsConnection_pageInfo(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + return nil, fmt.Errorf("no field named %q was found under type EarningsConnection", field.Name) }, } defer func() { @@ -13437,116 +13901,92 @@ func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field } }() ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field___Field_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + if fc.Args, err = ec.field_UserRewards_history_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { ec.Error(ctx, err) return fc, err } return fc, nil } -func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_id(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_type, + ec.fieldContext_Vehicle_id, func(ctx context.Context) (any, error) { - return obj.Type, nil + return obj.ID, nil }, nil, - ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalNID2string, true, true, ) } -func (ec *executionContext) fieldContext___Field_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "Vehicle", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_tokenId(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_isDeprecated, + ec.fieldContext_Vehicle_tokenId, func(ctx context.Context) (any, error) { - return obj.IsDeprecated(), nil + return obj.TokenID, nil }, nil, - ec.marshalNBoolean2bool, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext___Field_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_tokenId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_tokenDID(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Field_deprecationReason, + ec.fieldContext_Vehicle_tokenDID, func(ctx context.Context) (any, error) { - return obj.DeprecationReason(), nil + return obj.TokenDID, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_tokenDID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Field", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return nil, errors.New("field of type String does not have child fields") @@ -13555,536 +13995,553 @@ func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Con return fc, nil } -func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_manufacturer(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___InputValue_name, + ec.fieldContext_Vehicle_manufacturer, func(ctx context.Context) (any, error) { - return obj.Name, nil + return ec.Resolvers.Vehicle().Manufacturer(ctx, obj) }, nil, - ec.marshalNString2string, + ec.marshalNManufacturer2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐManufacturer, true, true, ) } -func (ec *executionContext) fieldContext___InputValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_manufacturer(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__InputValue", + Object: "Vehicle", Field: field, - IsMethod: false, - IsResolver: false, + IsMethod: true, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext___InputValue_description, - func(ctx context.Context) (any, error) { - return obj.Description(), nil - }, - nil, - ec.marshalOString2ᚖstring, - true, - false, - ) -} - -func (ec *executionContext) fieldContext___InputValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "__InputValue", - Field: field, - IsMethod: true, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "id": + return ec.fieldContext_Manufacturer_id(ctx, field) + case "tokenId": + return ec.fieldContext_Manufacturer_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Manufacturer_tokenDID(ctx, field) + case "name": + return ec.fieldContext_Manufacturer_name(ctx, field) + case "owner": + return ec.fieldContext_Manufacturer_owner(ctx, field) + case "tableId": + return ec.fieldContext_Manufacturer_tableId(ctx, field) + case "mintedAt": + return ec.fieldContext_Manufacturer_mintedAt(ctx, field) + case "aftermarketDevices": + return ec.fieldContext_Manufacturer_aftermarketDevices(ctx, field) + case "deviceDefinitions": + return ec.fieldContext_Manufacturer_deviceDefinitions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Manufacturer", field.Name) }, } return fc, nil } -func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_owner(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___InputValue_type, + ec.fieldContext_Vehicle_owner, func(ctx context.Context) (any, error) { - return obj.Type, nil + return obj.Owner, nil }, nil, - ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalNAddress2githubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress, true, true, ) } -func (ec *executionContext) fieldContext___InputValue_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__InputValue", + Object: "Vehicle", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, errors.New("field of type Address does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_mintedAt(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___InputValue_defaultValue, + ec.fieldContext_Vehicle_mintedAt, func(ctx context.Context) (any, error) { - return obj.DefaultValue, nil + return obj.MintedAt, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNTime2timeᚐTime, + true, true, - false, ) } -func (ec *executionContext) fieldContext___InputValue_defaultValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_mintedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__InputValue", + Object: "Vehicle", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___InputValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_aftermarketDevice(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___InputValue_isDeprecated, + ec.fieldContext_Vehicle_aftermarketDevice, func(ctx context.Context) (any, error) { - return obj.IsDeprecated(), nil + return ec.Resolvers.Vehicle().AftermarketDevice(ctx, obj) }, nil, - ec.marshalNBoolean2bool, - true, + ec.marshalOAftermarketDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐAftermarketDevice, true, + false, ) } -func (ec *executionContext) fieldContext___InputValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_aftermarketDevice(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__InputValue", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + switch field.Name { + case "id": + return ec.fieldContext_AftermarketDevice_id(ctx, field) + case "tokenId": + return ec.fieldContext_AftermarketDevice_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_AftermarketDevice_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_AftermarketDevice_manufacturer(ctx, field) + case "address": + return ec.fieldContext_AftermarketDevice_address(ctx, field) + case "owner": + return ec.fieldContext_AftermarketDevice_owner(ctx, field) + case "serial": + return ec.fieldContext_AftermarketDevice_serial(ctx, field) + case "imei": + return ec.fieldContext_AftermarketDevice_imei(ctx, field) + case "devEUI": + return ec.fieldContext_AftermarketDevice_devEUI(ctx, field) + case "hardwareRevision": + return ec.fieldContext_AftermarketDevice_hardwareRevision(ctx, field) + case "mintedAt": + return ec.fieldContext_AftermarketDevice_mintedAt(ctx, field) + case "claimedAt": + return ec.fieldContext_AftermarketDevice_claimedAt(ctx, field) + case "vehicle": + return ec.fieldContext_AftermarketDevice_vehicle(ctx, field) + case "beneficiary": + return ec.fieldContext_AftermarketDevice_beneficiary(ctx, field) + case "name": + return ec.fieldContext_AftermarketDevice_name(ctx, field) + case "image": + return ec.fieldContext_AftermarketDevice_image(ctx, field) + case "earnings": + return ec.fieldContext_AftermarketDevice_earnings(ctx, field) + case "pairedAt": + return ec.fieldContext_AftermarketDevice_pairedAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type AftermarketDevice", field.Name) }, } return fc, nil } -func (ec *executionContext) ___InputValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_privileges(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___InputValue_deprecationReason, + ec.fieldContext_Vehicle_privileges, func(ctx context.Context) (any, error) { - return obj.DeprecationReason(), nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Vehicle().Privileges(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string), fc.Args["filterBy"].(*model.PrivilegeFilterBy)) }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNPrivilegesConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPrivilegesConnection, + true, true, - false, ) } -func (ec *executionContext) fieldContext___InputValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_privileges(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__InputValue", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_PrivilegesConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_PrivilegesConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_PrivilegesConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_PrivilegesConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PrivilegesConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Vehicle_privileges_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_sacds(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_description, + ec.fieldContext_Vehicle_sacds, func(ctx context.Context) (any, error) { - return obj.Description(), nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Vehicle().Sacds(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNSacdConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacdConnection, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Schema_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_sacds(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "totalCount": + return ec.fieldContext_SacdConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_SacdConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_SacdConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_SacdConnection_pageInfo(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type SacdConnection", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Vehicle_sacds_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_sacd(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_types, + ec.fieldContext_Vehicle_sacd, func(ctx context.Context) (any, error) { - return obj.Types(), nil + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.Vehicle().Sacd(ctx, obj, fc.Args["grantee"].(common.Address)) }, nil, - ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, - true, + ec.marshalOSacd2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSacd, true, + false, ) } -func (ec *executionContext) fieldContext___Schema_types(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_sacd(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + case "grantee": + return ec.fieldContext_Sacd_grantee(ctx, field) + case "permissions": + return ec.fieldContext_Sacd_permissions(ctx, field) + case "source": + return ec.fieldContext_Sacd_source(ctx, field) + case "createdAt": + return ec.fieldContext_Sacd_createdAt(ctx, field) + case "expiresAt": + return ec.fieldContext_Sacd_expiresAt(ctx, field) + case "template": + return ec.fieldContext_Sacd_template(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Sacd", field.Name) }, } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Vehicle_sacd_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } return fc, nil } -func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_syntheticDevice(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_queryType, + ec.fieldContext_Vehicle_syntheticDevice, func(ctx context.Context) (any, error) { - return obj.QueryType(), nil + return ec.Resolvers.Vehicle().SyntheticDevice(ctx, obj) }, nil, - ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, - true, + ec.marshalOSyntheticDevice2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDevice, true, + false, ) } -func (ec *executionContext) fieldContext___Schema_queryType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_syntheticDevice(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) + case "id": + return ec.fieldContext_SyntheticDevice_id(ctx, field) case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + return ec.fieldContext_SyntheticDevice_name(ctx, field) + case "tokenId": + return ec.fieldContext_SyntheticDevice_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_SyntheticDevice_tokenDID(ctx, field) + case "integrationId": + return ec.fieldContext_SyntheticDevice_integrationId(ctx, field) + case "address": + return ec.fieldContext_SyntheticDevice_address(ctx, field) + case "mintedAt": + return ec.fieldContext_SyntheticDevice_mintedAt(ctx, field) + case "vehicle": + return ec.fieldContext_SyntheticDevice_vehicle(ctx, field) + case "connection": + return ec.fieldContext_SyntheticDevice_connection(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type SyntheticDevice", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_definition(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_mutationType, + ec.fieldContext_Vehicle_definition, func(ctx context.Context) (any, error) { - return obj.MutationType(), nil + return obj.Definition, nil }, nil, - ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalODefinition2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDefinition, true, false, ) } -func (ec *executionContext) fieldContext___Schema_mutationType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_definition(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + case "id": + return ec.fieldContext_Definition_id(ctx, field) + case "make": + return ec.fieldContext_Definition_make(ctx, field) + case "model": + return ec.fieldContext_Definition_model(ctx, field) + case "year": + return ec.fieldContext_Definition_year(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Definition", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_dcn(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_subscriptionType, + ec.fieldContext_Vehicle_dcn, func(ctx context.Context) (any, error) { - return obj.SubscriptionType(), nil + return ec.Resolvers.Vehicle().Dcn(ctx, obj) }, nil, - ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalODCN2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐDcn, true, false, ) } -func (ec *executionContext) fieldContext___Schema_subscriptionType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_dcn(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) + case "id": + return ec.fieldContext_DCN_id(ctx, field) + case "node": + return ec.fieldContext_DCN_node(ctx, field) + case "tokenId": + return ec.fieldContext_DCN_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_DCN_tokenDID(ctx, field) + case "owner": + return ec.fieldContext_DCN_owner(ctx, field) + case "expiresAt": + return ec.fieldContext_DCN_expiresAt(ctx, field) + case "mintedAt": + return ec.fieldContext_DCN_mintedAt(ctx, field) case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + return ec.fieldContext_DCN_name(ctx, field) + case "vehicle": + return ec.fieldContext_DCN_vehicle(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type DCN", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_name(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Schema_directives, + ec.fieldContext_Vehicle_name, func(ctx context.Context) (any, error) { - return obj.Directives(), nil + return obj.Name, nil }, nil, - ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext___Schema_directives(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Schema", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "name": - return ec.fieldContext___Directive_name(ctx, field) - case "description": - return ec.fieldContext___Directive_description(ctx, field) - case "isRepeatable": - return ec.fieldContext___Directive_isRepeatable(ctx, field) - case "locations": - return ec.fieldContext___Directive_locations(ctx, field) - case "args": - return ec.fieldContext___Directive_args(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_imageURI(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_kind, + ec.fieldContext_Vehicle_imageURI, func(ctx context.Context) (any, error) { - return obj.Kind(), nil + return obj.ImageURI, nil }, nil, - ec.marshalN__TypeKind2string, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext___Type_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_imageURI(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type __TypeKind does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_image(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_name, + ec.fieldContext_Vehicle_image, func(ctx context.Context) (any, error) { - return obj.Name(), nil + return obj.Image, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_image(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return nil, errors.New("field of type String does not have child fields") @@ -14093,56 +14550,62 @@ func (ec *executionContext) fieldContext___Type_name(_ context.Context, field gr return fc, nil } -func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_earnings(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_description, + ec.fieldContext_Vehicle_earnings, func(ctx context.Context) (any, error) { - return obj.Description(), nil + return ec.Resolvers.Vehicle().Earnings(ctx, obj) }, nil, - ec.marshalOString2ᚖstring, + ec.marshalOVehicleEarnings2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleEarnings, true, false, ) } -func (ec *executionContext) fieldContext___Type_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_earnings(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + switch field.Name { + case "totalTokens": + return ec.fieldContext_VehicleEarnings_totalTokens(ctx, field) + case "history": + return ec.fieldContext_VehicleEarnings_history(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type VehicleEarnings", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_dataURI(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_specifiedByURL, + ec.fieldContext_Vehicle_dataURI, func(ctx context.Context) (any, error) { - return obj.SpecifiedByURL(), nil + return obj.DataURI, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_dataURI(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return nil, errors.New("field of type String does not have child fields") @@ -14151,389 +14614,2539 @@ func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context return fc, nil } -func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_stake(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_fields, + ec.fieldContext_Vehicle_stake, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil + return ec.Resolvers.Vehicle().Stake(ctx, obj) }, nil, - ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ, + ec.marshalOStake2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStake, true, false, ) } -func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_stake(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext___Field_name(ctx, field) - case "description": - return ec.fieldContext___Field_description(ctx, field) - case "args": - return ec.fieldContext___Field_args(ctx, field) - case "type": - return ec.fieldContext___Field_type(ctx, field) - case "isDeprecated": - return ec.fieldContext___Field_isDeprecated(ctx, field) - case "deprecationReason": - return ec.fieldContext___Field_deprecationReason(ctx, field) + case "tokenId": + return ec.fieldContext_Stake_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Stake_tokenDID(ctx, field) + case "owner": + return ec.fieldContext_Stake_owner(ctx, field) + case "level": + return ec.fieldContext_Stake_level(ctx, field) + case "points": + return ec.fieldContext_Stake_points(ctx, field) + case "amount": + return ec.fieldContext_Stake_amount(ctx, field) + case "stakedAt": + return ec.fieldContext_Stake_stakedAt(ctx, field) + case "endsAt": + return ec.fieldContext_Stake_endsAt(ctx, field) + case "withdrawnAt": + return ec.fieldContext_Stake_withdrawnAt(ctx, field) + case "vehicle": + return ec.fieldContext_Stake_vehicle(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Stake", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _Vehicle_storageNode(ctx context.Context, field graphql.CollectedField, obj *model.Vehicle) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_interfaces, + ec.fieldContext_Vehicle_storageNode, func(ctx context.Context) (any, error) { - return obj.Interfaces(), nil + return ec.Resolvers.Vehicle().StorageNode(ctx, obj) }, nil, - ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, + ec.marshalOStorageNode2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐStorageNode, true, false, ) } -func (ec *executionContext) fieldContext___Type_interfaces(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Vehicle_storageNode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "Vehicle", Field: field, IsMethod: true, - IsResolver: false, + IsResolver: true, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + case "label": + return ec.fieldContext_StorageNode_label(ctx, field) + case "address": + return ec.fieldContext_StorageNode_address(ctx, field) + case "owner": + return ec.fieldContext_StorageNode_owner(ctx, field) + case "tokenId": + return ec.fieldContext_StorageNode_tokenId(ctx, field) + case "uri": + return ec.fieldContext_StorageNode_uri(ctx, field) + case "tokenDID": + return ec.fieldContext_StorageNode_tokenDID(ctx, field) + case "mintedAt": + return ec.fieldContext_StorageNode_mintedAt(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type StorageNode", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _VehicleConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_possibleTypes, + ec.fieldContext_VehicleConnection_totalCount, func(ctx context.Context) (any, error) { - return obj.PossibleTypes(), nil + return obj.TotalCount, nil }, nil, - ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, + ec.marshalNInt2int, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_possibleTypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_VehicleConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "VehicleConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _VehicleConnection_edges(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_enumValues, + ec.fieldContext_VehicleConnection_edges, func(ctx context.Context) (any, error) { - fc := graphql.GetFieldContext(ctx) - return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil + return obj.Edges, nil }, nil, - ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ, + ec.marshalNVehicleEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleEdgeᚄ, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_VehicleConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "VehicleConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext___EnumValue_name(ctx, field) - case "description": - return ec.fieldContext___EnumValue_description(ctx, field) - case "isDeprecated": - return ec.fieldContext___EnumValue_isDeprecated(ctx, field) - case "deprecationReason": - return ec.fieldContext___EnumValue_deprecationReason(ctx, field) + case "node": + return ec.fieldContext_VehicleEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_VehicleEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name) + return nil, fmt.Errorf("no field named %q was found under type VehicleEdge", field.Name) }, } - defer func() { - if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) - } - }() - ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { - ec.Error(ctx, err) - return fc, err - } return fc, nil } -func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _VehicleConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_inputFields, + ec.fieldContext_VehicleConnection_nodes, func(ctx context.Context) (any, error) { - return obj.InputFields(), nil + return obj.Nodes, nil }, nil, - ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + ec.marshalNVehicle2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicleᚄ, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_inputFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_VehicleConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "VehicleConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "name": - return ec.fieldContext___InputValue_name(ctx, field) - case "description": - return ec.fieldContext___InputValue_description(ctx, field) - case "type": - return ec.fieldContext___InputValue_type(ctx, field) - case "defaultValue": - return ec.fieldContext___InputValue_defaultValue(ctx, field) - case "isDeprecated": - return ec.fieldContext___InputValue_isDeprecated(ctx, field) - case "deprecationReason": - return ec.fieldContext___InputValue_deprecationReason(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + case "id": + return ec.fieldContext_Vehicle_id(ctx, field) + case "tokenId": + return ec.fieldContext_Vehicle_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Vehicle_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_Vehicle_manufacturer(ctx, field) + case "owner": + return ec.fieldContext_Vehicle_owner(ctx, field) + case "mintedAt": + return ec.fieldContext_Vehicle_mintedAt(ctx, field) + case "aftermarketDevice": + return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) + case "privileges": + return ec.fieldContext_Vehicle_privileges(ctx, field) + case "sacds": + return ec.fieldContext_Vehicle_sacds(ctx, field) + case "sacd": + return ec.fieldContext_Vehicle_sacd(ctx, field) + case "syntheticDevice": + return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) + case "definition": + return ec.fieldContext_Vehicle_definition(ctx, field) + case "dcn": + return ec.fieldContext_Vehicle_dcn(ctx, field) + case "name": + return ec.fieldContext_Vehicle_name(ctx, field) + case "imageURI": + return ec.fieldContext_Vehicle_imageURI(ctx, field) + case "image": + return ec.fieldContext_Vehicle_image(ctx, field) + case "earnings": + return ec.fieldContext_Vehicle_earnings(ctx, field) + case "dataURI": + return ec.fieldContext_Vehicle_dataURI(ctx, field) + case "stake": + return ec.fieldContext_Vehicle_stake(ctx, field) + case "storageNode": + return ec.fieldContext_Vehicle_storageNode(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _VehicleConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *model.VehicleConnection) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_ofType, + ec.fieldContext_VehicleConnection_pageInfo, func(ctx context.Context) (any, error) { - return obj.OfType(), nil + return obj.PageInfo, nil }, nil, - ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + ec.marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_ofType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_VehicleConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "VehicleConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "kind": - return ec.fieldContext___Type_kind(ctx, field) - case "name": - return ec.fieldContext___Type_name(ctx, field) - case "description": - return ec.fieldContext___Type_description(ctx, field) - case "specifiedByURL": - return ec.fieldContext___Type_specifiedByURL(ctx, field) - case "fields": - return ec.fieldContext___Type_fields(ctx, field) - case "interfaces": - return ec.fieldContext___Type_interfaces(ctx, field) - case "possibleTypes": - return ec.fieldContext___Type_possibleTypes(ctx, field) - case "enumValues": - return ec.fieldContext___Type_enumValues(ctx, field) - case "inputFields": - return ec.fieldContext___Type_inputFields(ctx, field) - case "ofType": - return ec.fieldContext___Type_ofType(ctx, field) - case "isOneOf": - return ec.fieldContext___Type_isOneOf(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) ___Type_isOneOf(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { +func (ec *executionContext) _VehicleEarnings_totalTokens(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEarnings) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext___Type_isOneOf, + ec.fieldContext_VehicleEarnings_totalTokens, func(ctx context.Context) (any, error) { - return obj.IsOneOf(), nil + return obj.TotalTokens, nil }, nil, - ec.marshalOBoolean2bool, + ec.marshalNBigDecimal2ᚖgithubᚗcomᚋericlagergrenᚋdecimalᚐBig, + true, true, - false, ) } -func (ec *executionContext) fieldContext___Type_isOneOf(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_VehicleEarnings_totalTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "__Type", + Object: "VehicleEarnings", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type BigDecimal does not have child fields") }, } return fc, nil } -// endregion **************************** field.gotpl ***************************** - -// region **************************** input.gotpl ***************************** - -func (ec *executionContext) unmarshalInputAccountBy(ctx context.Context, obj any) (model.AccountBy, error) { - var it model.AccountBy - if obj == nil { - return it, nil - } - - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _VehicleEarnings_history(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEarnings) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_VehicleEarnings_history, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return ec.Resolvers.VehicleEarnings().History(ctx, obj, fc.Args["first"].(*int), fc.Args["after"].(*string), fc.Args["last"].(*int), fc.Args["before"].(*string)) + }, + nil, + ec.marshalNEarningsConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐEarningsConnection, + true, + true, + ) +} - fieldsInOrder := [...]string{"address"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "address": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err +func (ec *executionContext) fieldContext_VehicleEarnings_history(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "VehicleEarnings", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "totalCount": + return ec.fieldContext_EarningsConnection_totalCount(ctx, field) + case "edges": + return ec.fieldContext_EarningsConnection_edges(ctx, field) + case "nodes": + return ec.fieldContext_EarningsConnection_nodes(ctx, field) + case "pageInfo": + return ec.fieldContext_EarningsConnection_pageInfo(ctx, field) } - it.Address = data + return nil, fmt.Errorf("no field named %q was found under type EarningsConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_VehicleEarnings_history_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err } - return it, nil + return fc, nil } -func (ec *executionContext) unmarshalInputAftermarketDeviceBy(ctx context.Context, obj any) (model.AftermarketDeviceBy, error) { - var it model.AftermarketDeviceBy - if obj == nil { - return it, nil - } +func (ec *executionContext) _VehicleEdge_node(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEdge) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_VehicleEdge_node, + func(ctx context.Context) (any, error) { + return obj.Node, nil + }, + nil, + ec.marshalNVehicle2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐVehicle, + true, + true, + ) +} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v +func (ec *executionContext) fieldContext_VehicleEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "VehicleEdge", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Vehicle_id(ctx, field) + case "tokenId": + return ec.fieldContext_Vehicle_tokenId(ctx, field) + case "tokenDID": + return ec.fieldContext_Vehicle_tokenDID(ctx, field) + case "manufacturer": + return ec.fieldContext_Vehicle_manufacturer(ctx, field) + case "owner": + return ec.fieldContext_Vehicle_owner(ctx, field) + case "mintedAt": + return ec.fieldContext_Vehicle_mintedAt(ctx, field) + case "aftermarketDevice": + return ec.fieldContext_Vehicle_aftermarketDevice(ctx, field) + case "privileges": + return ec.fieldContext_Vehicle_privileges(ctx, field) + case "sacds": + return ec.fieldContext_Vehicle_sacds(ctx, field) + case "sacd": + return ec.fieldContext_Vehicle_sacd(ctx, field) + case "syntheticDevice": + return ec.fieldContext_Vehicle_syntheticDevice(ctx, field) + case "definition": + return ec.fieldContext_Vehicle_definition(ctx, field) + case "dcn": + return ec.fieldContext_Vehicle_dcn(ctx, field) + case "name": + return ec.fieldContext_Vehicle_name(ctx, field) + case "imageURI": + return ec.fieldContext_Vehicle_imageURI(ctx, field) + case "image": + return ec.fieldContext_Vehicle_image(ctx, field) + case "earnings": + return ec.fieldContext_Vehicle_earnings(ctx, field) + case "dataURI": + return ec.fieldContext_Vehicle_dataURI(ctx, field) + case "stake": + return ec.fieldContext_Vehicle_stake(ctx, field) + case "storageNode": + return ec.fieldContext_Vehicle_storageNode(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Vehicle", field.Name) + }, } + return fc, nil +} + +func (ec *executionContext) _VehicleEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *model.VehicleEdge) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_VehicleEdge_cursor, + func(ctx context.Context) (any, error) { + return obj.Cursor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_VehicleEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "VehicleEdge", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Directive_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Directive_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Directive", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Directive_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Directive_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Directive", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Directive_isRepeatable, + func(ctx context.Context) (any, error) { + return obj.IsRepeatable, nil + }, + nil, + ec.marshalNBoolean2bool, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Directive_isRepeatable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Directive", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Directive_locations, + func(ctx context.Context) (any, error) { + return obj.Locations, nil + }, + nil, + ec.marshalN__DirectiveLocation2ᚕstringᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Directive_locations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Directive", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type __DirectiveLocation does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Directive_args, + func(ctx context.Context) (any, error) { + return obj.Args, nil + }, + nil, + ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Directive", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___InputValue_name(ctx, field) + case "description": + return ec.fieldContext___InputValue_description(ctx, field) + case "type": + return ec.fieldContext___InputValue_type(ctx, field) + case "defaultValue": + return ec.fieldContext___InputValue_defaultValue(ctx, field) + case "isDeprecated": + return ec.fieldContext___InputValue_isDeprecated(ctx, field) + case "deprecationReason": + return ec.fieldContext___InputValue_deprecationReason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field___Directive_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___EnumValue_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___EnumValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___EnumValue_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___EnumValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___EnumValue_isDeprecated, + func(ctx context.Context) (any, error) { + return obj.IsDeprecated(), nil + }, + nil, + ec.marshalNBoolean2bool, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___EnumValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___EnumValue_deprecationReason, + func(ctx context.Context) (any, error) { + return obj.DeprecationReason(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___EnumValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__EnumValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Field_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Field_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_args, + func(ctx context.Context) (any, error) { + return obj.Args, nil + }, + nil, + ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___InputValue_name(ctx, field) + case "description": + return ec.fieldContext___InputValue_description(ctx, field) + case "type": + return ec.fieldContext___InputValue_type(ctx, field) + case "defaultValue": + return ec.fieldContext___InputValue_defaultValue(ctx, field) + case "isDeprecated": + return ec.fieldContext___InputValue_isDeprecated(ctx, field) + case "deprecationReason": + return ec.fieldContext___InputValue_deprecationReason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field___Field_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_type, + func(ctx context.Context) (any, error) { + return obj.Type, nil + }, + nil, + ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Field_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_isDeprecated, + func(ctx context.Context) (any, error) { + return obj.IsDeprecated(), nil + }, + nil, + ec.marshalNBoolean2bool, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Field_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Field_deprecationReason, + func(ctx context.Context) (any, error) { + return obj.DeprecationReason(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Field", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_name, + func(ctx context.Context) (any, error) { + return obj.Name, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___InputValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___InputValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_type, + func(ctx context.Context) (any, error) { + return obj.Type, nil + }, + nil, + ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___InputValue_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_defaultValue, + func(ctx context.Context) (any, error) { + return obj.DefaultValue, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___InputValue_defaultValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_isDeprecated, + func(ctx context.Context) (any, error) { + return obj.IsDeprecated(), nil + }, + nil, + ec.marshalNBoolean2bool, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___InputValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___InputValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___InputValue_deprecationReason, + func(ctx context.Context) (any, error) { + return obj.DeprecationReason(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___InputValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__InputValue", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Schema_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_types, + func(ctx context.Context) (any, error) { + return obj.Types(), nil + }, + nil, + ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Schema_types(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_queryType, + func(ctx context.Context) (any, error) { + return obj.QueryType(), nil + }, + nil, + ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Schema_queryType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_mutationType, + func(ctx context.Context) (any, error) { + return obj.MutationType(), nil + }, + nil, + ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Schema_mutationType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_subscriptionType, + func(ctx context.Context) (any, error) { + return obj.SubscriptionType(), nil + }, + nil, + ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Schema_subscriptionType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Schema_directives, + func(ctx context.Context) (any, error) { + return obj.Directives(), nil + }, + nil, + ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Schema_directives(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Schema", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___Directive_name(ctx, field) + case "description": + return ec.fieldContext___Directive_description(ctx, field) + case "isRepeatable": + return ec.fieldContext___Directive_isRepeatable(ctx, field) + case "locations": + return ec.fieldContext___Directive_locations(ctx, field) + case "args": + return ec.fieldContext___Directive_args(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_kind, + func(ctx context.Context) (any, error) { + return obj.Kind(), nil + }, + nil, + ec.marshalN__TypeKind2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext___Type_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type __TypeKind does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_name, + func(ctx context.Context) (any, error) { + return obj.Name(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_description, + func(ctx context.Context) (any, error) { + return obj.Description(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_specifiedByURL, + func(ctx context.Context) (any, error) { + return obj.SpecifiedByURL(), nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_fields, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil + }, + nil, + ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___Field_name(ctx, field) + case "description": + return ec.fieldContext___Field_description(ctx, field) + case "args": + return ec.fieldContext___Field_args(ctx, field) + case "type": + return ec.fieldContext___Field_type(ctx, field) + case "isDeprecated": + return ec.fieldContext___Field_isDeprecated(ctx, field) + case "deprecationReason": + return ec.fieldContext___Field_deprecationReason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_interfaces, + func(ctx context.Context) (any, error) { + return obj.Interfaces(), nil + }, + nil, + ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_interfaces(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_possibleTypes, + func(ctx context.Context) (any, error) { + return obj.PossibleTypes(), nil + }, + nil, + ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_possibleTypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_enumValues, + func(ctx context.Context) (any, error) { + fc := graphql.GetFieldContext(ctx) + return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil + }, + nil, + ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___EnumValue_name(ctx, field) + case "description": + return ec.fieldContext___EnumValue_description(ctx, field) + case "isDeprecated": + return ec.fieldContext___EnumValue_isDeprecated(ctx, field) + case "deprecationReason": + return ec.fieldContext___EnumValue_deprecationReason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_inputFields, + func(ctx context.Context) (any, error) { + return obj.InputFields(), nil + }, + nil, + ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_inputFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "name": + return ec.fieldContext___InputValue_name(ctx, field) + case "description": + return ec.fieldContext___InputValue_description(ctx, field) + case "type": + return ec.fieldContext___InputValue_type(ctx, field) + case "defaultValue": + return ec.fieldContext___InputValue_defaultValue(ctx, field) + case "isDeprecated": + return ec.fieldContext___InputValue_isDeprecated(ctx, field) + case "deprecationReason": + return ec.fieldContext___InputValue_deprecationReason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_ofType, + func(ctx context.Context) (any, error) { + return obj.OfType(), nil + }, + nil, + ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_ofType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "kind": + return ec.fieldContext___Type_kind(ctx, field) + case "name": + return ec.fieldContext___Type_name(ctx, field) + case "description": + return ec.fieldContext___Type_description(ctx, field) + case "specifiedByURL": + return ec.fieldContext___Type_specifiedByURL(ctx, field) + case "fields": + return ec.fieldContext___Type_fields(ctx, field) + case "interfaces": + return ec.fieldContext___Type_interfaces(ctx, field) + case "possibleTypes": + return ec.fieldContext___Type_possibleTypes(ctx, field) + case "enumValues": + return ec.fieldContext___Type_enumValues(ctx, field) + case "inputFields": + return ec.fieldContext___Type_inputFields(ctx, field) + case "ofType": + return ec.fieldContext___Type_ofType(ctx, field) + case "isOneOf": + return ec.fieldContext___Type_isOneOf(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) ___Type_isOneOf(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext___Type_isOneOf, + func(ctx context.Context) (any, error) { + return obj.IsOneOf(), nil + }, + nil, + ec.marshalOBoolean2bool, + true, + false, + ) +} + +func (ec *executionContext) fieldContext___Type_isOneOf(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "__Type", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +// endregion **************************** field.gotpl ***************************** + +// region **************************** input.gotpl ***************************** + +func (ec *executionContext) unmarshalInputAccountBy(ctx context.Context, obj any) (model.AccountBy, error) { + var it model.AccountBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"address"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "address": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Address = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputAftermarketDeviceBy(ctx context.Context, obj any) (model.AftermarketDeviceBy, error) { + var it model.AftermarketDeviceBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tokenId", "tokenDID", "address", "serial", "imei", "devEUI"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "tokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.TokenID = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + case "address": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Address = data + case "serial": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("serial")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Serial = data + case "imei": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("imei")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Imei = data + case "devEUI": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("devEUI")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DevEui = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputAftermarketDevicesFilter(ctx context.Context, obj any) (model.AftermarketDevicesFilter, error) { + var it model.AftermarketDevicesFilter + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"owner", "beneficiary", "manufacturerId"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + case "beneficiary": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("beneficiary")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Beneficiary = data + case "manufacturerId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("manufacturerId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.ManufacturerID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputConnectionBy(ctx context.Context, obj any) (model.ConnectionBy, error) { + var it model.ConnectionBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "address", "tokenId", "tokenDID"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "address": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Address = data + case "tokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) + data, err := ec.unmarshalOBigInt2ᚖmathᚋbigᚐInt(ctx, v) + if err != nil { + return it, err + } + it.TokenID = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDCNBy(ctx context.Context, obj any) (model.DCNBy, error) { + var it model.DCNBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"node", "tokenDID", "name"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "node": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("node")) + data, err := ec.unmarshalOBytes2ᚕbyte(ctx, v) + if err != nil { + return it, err + } + it.Node = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDCNFilter(ctx context.Context, obj any) (model.DCNFilter, error) { + var it model.DCNFilter + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"owner"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDeveloperLicenseBy(ctx context.Context, obj any) (model.DeveloperLicenseBy, error) { + var it model.DeveloperLicenseBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"clientId", "alias", "tokenId", "tokenDID"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "clientId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientId")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.ClientID = data + case "alias": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("alias")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Alias = data + case "tokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.TokenID = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDeveloperLicenseFilterBy(ctx context.Context, obj any) (model.DeveloperLicenseFilterBy, error) { + var it model.DeveloperLicenseFilterBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"signer", "owner"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "signer": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("signer")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Signer = data + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDeviceDefinitionBy(ctx context.Context, obj any) (model.DeviceDefinitionBy, error) { + var it model.DeviceDefinitionBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"id"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.ID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputDeviceDefinitionFilter(ctx context.Context, obj any) (model.DeviceDefinitionFilter, error) { + var it model.DeviceDefinitionFilter + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"model", "year"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "model": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("model")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Model = data + case "year": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("year")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.Year = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputManufacturerBy(ctx context.Context, obj any) (model.ManufacturerBy, error) { + var it model.ManufacturerBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"name", "tokenId", "slug", "tokenDID"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "tokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.TokenID = data + case "slug": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("slug")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Slug = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputPrivilegeFilterBy(ctx context.Context, obj any) (model.PrivilegeFilterBy, error) { + var it model.PrivilegeFilterBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"user", "privilegeId"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "user": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.User = data + case "privilegeId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("privilegeId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.PrivilegeID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputStakeFilterBy(ctx context.Context, obj any) (model.StakeFilterBy, error) { + var it model.StakeFilterBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"owner", "attachable"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + case "attachable": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("attachable")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.Attachable = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputSyntheticDeviceBy(ctx context.Context, obj any) (model.SyntheticDeviceBy, error) { + var it model.SyntheticDeviceBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tokenId", "tokenDID", "address"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "tokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.TokenID = data + case "tokenDID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenDID = data + case "address": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Address = data + } + } + return it, nil +} - fieldsInOrder := [...]string{"tokenId", "tokenDID", "address", "serial", "imei", "devEUI"} +func (ec *executionContext) unmarshalInputSyntheticDevicesFilter(ctx context.Context, obj any) (model.SyntheticDevicesFilter, error) { + var it model.SyntheticDevicesFilter + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"owner", "integrationId"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + case "integrationId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("integrationId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.IntegrationID = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputTemplateBy(ctx context.Context, obj any) (model.TemplateBy, error) { + var it model.TemplateBy + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tokenId", "cid"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -14542,775 +17155,809 @@ func (ec *executionContext) unmarshalInputAftermarketDeviceBy(ctx context.Contex switch k { case "tokenId": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + data, err := ec.unmarshalOBigInt2ᚖmathᚋbigᚐInt(ctx, v) if err != nil { return it, err } it.TokenID = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) + case "cid": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cid")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenDID = data - case "address": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) + it.Cid = data + } + } + return it, nil +} + +func (ec *executionContext) unmarshalInputVehiclesFilter(ctx context.Context, obj any) (model.VehiclesFilter, error) { + var it model.VehiclesFilter + if obj == nil { + return it, nil + } + + asMap := map[string]any{} + for k, v := range obj.(map[string]any) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"privileged", "owner", "make", "model", "year", "manufacturerTokenId", "deviceDefinitionId"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "privileged": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("privileged")) data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) if err != nil { return it, err } - it.Address = data - case "serial": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("serial")) + it.Privileged = data + case "owner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) + data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) + if err != nil { + return it, err + } + it.Owner = data + case "make": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("make")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Serial = data - case "imei": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("imei")) + it.Make = data + case "model": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("model")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Imei = data - case "devEUI": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("devEUI")) + it.Model = data + case "year": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("year")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.Year = data + case "manufacturerTokenId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("manufacturerTokenId")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) + if err != nil { + return it, err + } + it.ManufacturerTokenID = data + case "deviceDefinitionId": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deviceDefinitionId")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DevEui = data + it.DeviceDefinitionID = data } } return it, nil } -func (ec *executionContext) unmarshalInputAftermarketDevicesFilter(ctx context.Context, obj any) (model.AftermarketDevicesFilter, error) { - var it model.AftermarketDevicesFilter - if obj == nil { - return it, nil +// endregion **************************** input.gotpl ***************************** + +// region ************************** interface.gotpl *************************** + +func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj model.Node) graphql.Marshaler { + switch obj := (obj).(type) { + case nil: + return graphql.Null + case model.Vehicle: + return ec._Vehicle(ctx, sel, &obj) + case *model.Vehicle: + if obj == nil { + return graphql.Null + } + return ec._Vehicle(ctx, sel, obj) + case model.SyntheticDevice: + return ec._SyntheticDevice(ctx, sel, &obj) + case *model.SyntheticDevice: + if obj == nil { + return graphql.Null + } + return ec._SyntheticDevice(ctx, sel, obj) + case model.Manufacturer: + return ec._Manufacturer(ctx, sel, &obj) + case *model.Manufacturer: + if obj == nil { + return graphql.Null + } + return ec._Manufacturer(ctx, sel, obj) + case model.Dcn: + return ec._DCN(ctx, sel, &obj) + case *model.Dcn: + if obj == nil { + return graphql.Null + } + return ec._DCN(ctx, sel, obj) + case model.AftermarketDevice: + return ec._AftermarketDevice(ctx, sel, &obj) + case *model.AftermarketDevice: + if obj == nil { + return graphql.Null + } + return ec._AftermarketDevice(ctx, sel, obj) + default: + if typedObj, ok := obj.(graphql.Marshaler); ok { + return typedObj + } else { + panic(fmt.Errorf("unexpected type %T; non-generated variants of Node must implement graphql.Marshaler", obj)) + } } +} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v +// endregion ************************** interface.gotpl *************************** + +// region **************************** object.gotpl **************************** + +var accountImplementors = []string{"Account"} + +func (ec *executionContext) _Account(ctx context.Context, sel ast.SelectionSet, obj *model.Account) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, accountImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("Account") + case "address": + out.Values[i] = ec._Account_address(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "sacds": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Account_sacds(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - fieldsInOrder := [...]string{"owner", "beneficiary", "manufacturerId"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + return out +} + +var aftermarketDeviceImplementors = []string{"AftermarketDevice", "Node"} + +func (ec *executionContext) _AftermarketDevice(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDevice) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AftermarketDevice") + case "id": + out.Values[i] = ec._AftermarketDevice_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.Owner = data - case "beneficiary": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("beneficiary")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + case "tokenId": + out.Values[i] = ec._AftermarketDevice_tokenId(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.Beneficiary = data - case "manufacturerId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("manufacturerId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "tokenDID": + out.Values[i] = ec._AftermarketDevice_tokenDID(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.ManufacturerID = data - } - } - return it, nil -} + case "manufacturer": + field := field -func (ec *executionContext) unmarshalInputConnectionBy(ctx context.Context, obj any) (model.ConnectionBy, error) { - var it model.ConnectionBy - if obj == nil { - return it, nil - } + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._AftermarketDevice_manufacturer(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) - fieldsInOrder := [...]string{"name", "address", "tokenId", "tokenDID"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue } - it.Name = data + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) case "address": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + out.Values[i] = ec._AftermarketDevice_address(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.Address = data - case "tokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOBigInt2ᚖmathᚋbigᚐInt(ctx, v) - if err != nil { - return it, err + case "owner": + out.Values[i] = ec._AftermarketDevice_owner(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.TokenID = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + case "serial": + out.Values[i] = ec._AftermarketDevice_serial(ctx, field, obj) + case "imei": + out.Values[i] = ec._AftermarketDevice_imei(ctx, field, obj) + case "devEUI": + out.Values[i] = ec._AftermarketDevice_devEUI(ctx, field, obj) + case "hardwareRevision": + out.Values[i] = ec._AftermarketDevice_hardwareRevision(ctx, field, obj) + case "mintedAt": + out.Values[i] = ec._AftermarketDevice_mintedAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.TokenDID = data - } - } - return it, nil -} + case "claimedAt": + out.Values[i] = ec._AftermarketDevice_claimedAt(ctx, field, obj) + case "vehicle": + field := field -func (ec *executionContext) unmarshalInputDCNBy(ctx context.Context, obj any) (model.DCNBy, error) { - var it model.DCNBy - if obj == nil { - return it, nil - } + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._AftermarketDevice_vehicle(ctx, field, obj) + return res + } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) - fieldsInOrder := [...]string{"node", "tokenDID", "name"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "node": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("node")) - data, err := ec.unmarshalOBytes2ᚕbyte(ctx, v) - if err != nil { - return it, err + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue } - it.Node = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "beneficiary": + out.Values[i] = ec._AftermarketDevice_beneficiary(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.TokenDID = data case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + out.Values[i] = ec._AftermarketDevice_name(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "image": + out.Values[i] = ec._AftermarketDevice_image(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "earnings": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._AftermarketDevice_earnings(ctx, field, obj) + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue } - it.Name = data + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "pairedAt": + out.Values[i] = ec._AftermarketDevice_pairedAt(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil -} - -func (ec *executionContext) unmarshalInputDCNFilter(ctx context.Context, obj any) (model.DCNFilter, error) { - var it model.DCNFilter - if obj == nil { - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - fieldsInOrder := [...]string{"owner"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Owner = data - } + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - return it, nil + + return out } -func (ec *executionContext) unmarshalInputDeveloperLicenseBy(ctx context.Context, obj any) (model.DeveloperLicenseBy, error) { - var it model.DeveloperLicenseBy - if obj == nil { - return it, nil - } +var aftermarketDeviceConnectionImplementors = []string{"AftermarketDeviceConnection"} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _AftermarketDeviceConnection(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceConnectionImplementors) - fieldsInOrder := [...]string{"clientId", "alias", "tokenId", "tokenDID"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "clientId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientId")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AftermarketDeviceConnection") + case "totalCount": + out.Values[i] = ec._AftermarketDeviceConnection_totalCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.ClientID = data - case "alias": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("alias")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + case "edges": + out.Values[i] = ec._AftermarketDeviceConnection_edges(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.Alias = data - case "tokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "nodes": + out.Values[i] = ec._AftermarketDeviceConnection_nodes(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.TokenID = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + case "pageInfo": + out.Values[i] = ec._AftermarketDeviceConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.TokenDID = data + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil -} - -func (ec *executionContext) unmarshalInputDeveloperLicenseFilterBy(ctx context.Context, obj any) (model.DeveloperLicenseFilterBy, error) { - var it model.DeveloperLicenseFilterBy - if obj == nil { - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - fieldsInOrder := [...]string{"signer", "owner"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "signer": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("signer")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Signer = data - case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Owner = data - } + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - return it, nil + + return out } -func (ec *executionContext) unmarshalInputDeviceDefinitionBy(ctx context.Context, obj any) (model.DeviceDefinitionBy, error) { - var it model.DeviceDefinitionBy - if obj == nil { - return it, nil - } +var aftermarketDeviceEarningsImplementors = []string{"AftermarketDeviceEarnings"} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _AftermarketDeviceEarnings(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceEarnings) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceEarningsImplementors) - fieldsInOrder := [...]string{"id"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalNString2string(ctx, v) - if err != nil { - return it, err + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AftermarketDeviceEarnings") + case "totalTokens": + out.Values[i] = ec._AftermarketDeviceEarnings_totalTokens(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - it.ID = data - } - } - return it, nil -} - -func (ec *executionContext) unmarshalInputDeviceDefinitionFilter(ctx context.Context, obj any) (model.DeviceDefinitionFilter, error) { - var it model.DeviceDefinitionFilter - if obj == nil { - return it, nil - } - - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + case "history": + field := field - fieldsInOrder := [...]string{"model", "year"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "model": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("model")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._AftermarketDeviceEarnings_history(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res } - it.Model = data - case "year": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("year")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue } - it.Year = data + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil -} - -func (ec *executionContext) unmarshalInputManufacturerBy(ctx context.Context, obj any) (model.ManufacturerBy, error) { - var it model.ManufacturerBy - if obj == nil { - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - fieldsInOrder := [...]string{"name", "tokenId", "slug", "tokenDID"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Name = data - case "tokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err - } - it.TokenID = data - case "slug": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("slug")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Slug = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.TokenDID = data - } + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - return it, nil + + return out } -func (ec *executionContext) unmarshalInputPrivilegeFilterBy(ctx context.Context, obj any) (model.PrivilegeFilterBy, error) { - var it model.PrivilegeFilterBy - if obj == nil { - return it, nil - } +var aftermarketDeviceEdgeImplementors = []string{"AftermarketDeviceEdge"} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _AftermarketDeviceEdge(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceEdgeImplementors) - fieldsInOrder := [...]string{"user", "privilegeId"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "user": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AftermarketDeviceEdge") + case "cursor": + out.Values[i] = ec._AftermarketDeviceEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.User = data - case "privilegeId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("privilegeId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "node": + out.Values[i] = ec._AftermarketDeviceEdge_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.PrivilegeID = data + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil -} - -func (ec *executionContext) unmarshalInputStakeFilterBy(ctx context.Context, obj any) (model.StakeFilterBy, error) { - var it model.StakeFilterBy - if obj == nil { - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - fieldsInOrder := [...]string{"owner", "attachable"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Owner = data - case "attachable": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("attachable")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.Attachable = data - } + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - return it, nil + + return out } -func (ec *executionContext) unmarshalInputSyntheticDeviceBy(ctx context.Context, obj any) (model.SyntheticDeviceBy, error) { - var it model.SyntheticDeviceBy - if obj == nil { - return it, nil - } +var connectionImplementors = []string{"Connection"} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _Connection(ctx context.Context, sel ast.SelectionSet, obj *model.Connection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, connectionImplementors) - fieldsInOrder := [...]string{"tokenId", "tokenDID", "address"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "tokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err - } - it.TokenID = data - case "tokenDID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenDID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("Connection") + case "name": + out.Values[i] = ec._Connection_name(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.TokenDID = data case "address": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("address")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + out.Values[i] = ec._Connection_address(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.Address = data - } - } - return it, nil -} - -func (ec *executionContext) unmarshalInputSyntheticDevicesFilter(ctx context.Context, obj any) (model.SyntheticDevicesFilter, error) { - var it model.SyntheticDevicesFilter - if obj == nil { - return it, nil - } - - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"owner", "integrationId"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err + out.Values[i] = ec._Connection_owner(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.Owner = data - case "integrationId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("integrationId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "tokenId": + out.Values[i] = ec._Connection_tokenId(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "tokenDID": + out.Values[i] = ec._Connection_tokenDID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.IntegrationID = data + case "mintedAt": + out.Values[i] = ec._Connection_mintedAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil -} - -func (ec *executionContext) unmarshalInputTemplateBy(ctx context.Context, obj any) (model.TemplateBy, error) { - var it model.TemplateBy - if obj == nil { - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null } - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - fieldsInOrder := [...]string{"tokenId", "cid"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "tokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenId")) - data, err := ec.unmarshalOBigInt2ᚖmathᚋbigᚐInt(ctx, v) - if err != nil { - return it, err - } - it.TokenID = data - case "cid": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cid")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Cid = data - } + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) } - return it, nil + + return out } -func (ec *executionContext) unmarshalInputVehiclesFilter(ctx context.Context, obj any) (model.VehiclesFilter, error) { - var it model.VehiclesFilter - if obj == nil { - return it, nil - } +var connectionConnectionImplementors = []string{"ConnectionConnection"} - asMap := map[string]any{} - for k, v := range obj.(map[string]any) { - asMap[k] = v - } +func (ec *executionContext) _ConnectionConnection(ctx context.Context, sel ast.SelectionSet, obj *model.ConnectionConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, connectionConnectionImplementors) - fieldsInOrder := [...]string{"privileged", "owner", "make", "model", "year", "manufacturerTokenId", "deviceDefinitionId"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "privileged": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("privileged")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Privileged = data - case "owner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("owner")) - data, err := ec.unmarshalOAddress2ᚖgithubᚗcomᚋethereumᚋgoᚑethereumᚋcommonᚐAddress(ctx, v) - if err != nil { - return it, err - } - it.Owner = data - case "make": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("make")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Make = data - case "model": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("model")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConnectionConnection") + case "totalCount": + out.Values[i] = ec._ConnectionConnection_totalCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.Model = data - case "year": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("year")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "edges": + out.Values[i] = ec._ConnectionConnection_edges(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.Year = data - case "manufacturerTokenId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("manufacturerTokenId")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) - if err != nil { - return it, err + case "nodes": + out.Values[i] = ec._ConnectionConnection_nodes(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.ManufacturerTokenID = data - case "deviceDefinitionId": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deviceDefinitionId")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err + case "pageInfo": + out.Values[i] = ec._ConnectionConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - it.DeviceDefinitionID = data + default: + panic("unknown field " + strconv.Quote(field.Name)) } } - return it, nil + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out } -// endregion **************************** input.gotpl ***************************** +var connectionEdgeImplementors = []string{"ConnectionEdge"} -// region ************************** interface.gotpl *************************** +func (ec *executionContext) _ConnectionEdge(ctx context.Context, sel ast.SelectionSet, obj *model.ConnectionEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, connectionEdgeImplementors) -func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj model.Node) graphql.Marshaler { - switch obj := (obj).(type) { - case nil: - return graphql.Null - case model.Vehicle: - return ec._Vehicle(ctx, sel, &obj) - case *model.Vehicle: - if obj == nil { - return graphql.Null - } - return ec._Vehicle(ctx, sel, obj) - case model.SyntheticDevice: - return ec._SyntheticDevice(ctx, sel, &obj) - case *model.SyntheticDevice: - if obj == nil { - return graphql.Null - } - return ec._SyntheticDevice(ctx, sel, obj) - case model.Manufacturer: - return ec._Manufacturer(ctx, sel, &obj) - case *model.Manufacturer: - if obj == nil { - return graphql.Null - } - return ec._Manufacturer(ctx, sel, obj) - case model.Dcn: - return ec._DCN(ctx, sel, &obj) - case *model.Dcn: - if obj == nil { - return graphql.Null - } - return ec._DCN(ctx, sel, obj) - case model.AftermarketDevice: - return ec._AftermarketDevice(ctx, sel, &obj) - case *model.AftermarketDevice: - if obj == nil { - return graphql.Null - } - return ec._AftermarketDevice(ctx, sel, obj) - default: - if typedObj, ok := obj.(graphql.Marshaler); ok { - return typedObj - } else { - panic(fmt.Errorf("unexpected type %T; non-generated variants of Node must implement graphql.Marshaler", obj)) + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConnectionEdge") + case "node": + out.Values[i] = ec._ConnectionEdge_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "cursor": + out.Values[i] = ec._ConnectionEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) } } -} + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } -// endregion ************************** interface.gotpl *************************** + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) -// region **************************** object.gotpl **************************** + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } -var accountImplementors = []string{"Account"} + return out +} -func (ec *executionContext) _Account(ctx context.Context, sel ast.SelectionSet, obj *model.Account) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, accountImplementors) +var dCNImplementors = []string{"DCN", "Node"} + +func (ec *executionContext) _DCN(ctx context.Context, sel ast.SelectionSet, obj *model.Dcn) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dCNImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Account") - case "address": - out.Values[i] = ec._Account_address(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DCN") + case "id": + out.Values[i] = ec._DCN_id(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "sacds": + case "node": + out.Values[i] = ec._DCN_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "tokenId": + out.Values[i] = ec._DCN_tokenId(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "tokenDID": + out.Values[i] = ec._DCN_tokenDID(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "owner": + out.Values[i] = ec._DCN_owner(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "expiresAt": + out.Values[i] = ec._DCN_expiresAt(ctx, field, obj) + case "mintedAt": + out.Values[i] = ec._DCN_mintedAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "name": + out.Values[i] = ec._DCN_name(ctx, field, obj) + case "vehicle": field := field - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Account_sacds(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } + res = ec._DCN_vehicle(ctx, field, obj) return res } @@ -15357,103 +18004,197 @@ func (ec *executionContext) _Account(ctx context.Context, sel ast.SelectionSet, return out } -var aftermarketDeviceImplementors = []string{"AftermarketDevice", "Node"} +var dCNConnectionImplementors = []string{"DCNConnection"} -func (ec *executionContext) _AftermarketDevice(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDevice) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceImplementors) +func (ec *executionContext) _DCNConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DCNConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dCNConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("AftermarketDevice") - case "id": - out.Values[i] = ec._AftermarketDevice_id(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DCNConnection") + case "totalCount": + out.Values[i] = ec._DCNConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + out.Invalids++ } - case "tokenId": - out.Values[i] = ec._AftermarketDevice_tokenId(ctx, field, obj) + case "edges": + out.Values[i] = ec._DCNConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + out.Invalids++ } - case "tokenDID": - out.Values[i] = ec._AftermarketDevice_tokenDID(ctx, field, obj) + case "nodes": + out.Values[i] = ec._DCNConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + out.Invalids++ } - case "manufacturer": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._AftermarketDevice_manufacturer(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res + case "pageInfo": + out.Values[i] = ec._DCNConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var dCNEdgeImplementors = []string{"DCNEdge"} + +func (ec *executionContext) _DCNEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DCNEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dCNEdgeImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("DCNEdge") + case "cursor": + out.Values[i] = ec._DCNEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "node": + out.Values[i] = ec._DCNEdge_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "address": - out.Values[i] = ec._AftermarketDevice_address(ctx, field, obj) + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var definitionImplementors = []string{"Definition"} + +func (ec *executionContext) _Definition(ctx context.Context, sel ast.SelectionSet, obj *model.Definition) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, definitionImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("Definition") + case "id": + out.Values[i] = ec._Definition_id(ctx, field, obj) + case "make": + out.Values[i] = ec._Definition_make(ctx, field, obj) + case "model": + out.Values[i] = ec._Definition_model(ctx, field, obj) + case "year": + out.Values[i] = ec._Definition_year(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.Deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.ProcessDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var developerLicenseImplementors = []string{"DeveloperLicense"} + +func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicense) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("DeveloperLicense") + case "tokenId": + out.Values[i] = ec._DeveloperLicense_tokenId(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "tokenDID": + out.Values[i] = ec._DeveloperLicense_tokenDID(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } case "owner": - out.Values[i] = ec._AftermarketDevice_owner(ctx, field, obj) + out.Values[i] = ec._DeveloperLicense_owner(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "serial": - out.Values[i] = ec._AftermarketDevice_serial(ctx, field, obj) - case "imei": - out.Values[i] = ec._AftermarketDevice_imei(ctx, field, obj) - case "devEUI": - out.Values[i] = ec._AftermarketDevice_devEUI(ctx, field, obj) - case "hardwareRevision": - out.Values[i] = ec._AftermarketDevice_hardwareRevision(ctx, field, obj) + case "clientId": + out.Values[i] = ec._DeveloperLicense_clientId(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "alias": + out.Values[i] = ec._DeveloperLicense_alias(ctx, field, obj) case "mintedAt": - out.Values[i] = ec._AftermarketDevice_mintedAt(ctx, field, obj) + out.Values[i] = ec._DeveloperLicense_mintedAt(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "claimedAt": - out.Values[i] = ec._AftermarketDevice_claimedAt(ctx, field, obj) - case "vehicle": + case "signers": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._AftermarketDevice_vehicle(ctx, field, obj) + res = ec._DeveloperLicense_signers(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } return res } @@ -15477,31 +18218,19 @@ func (ec *executionContext) _AftermarketDevice(ctx context.Context, sel ast.Sele } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "beneficiary": - out.Values[i] = ec._AftermarketDevice_beneficiary(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "name": - out.Values[i] = ec._AftermarketDevice_name(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "image": - out.Values[i] = ec._AftermarketDevice_image(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "earnings": + case "redirectURIs": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._AftermarketDevice_earnings(ctx, field, obj) + res = ec._DeveloperLicense_redirectURIs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } return res } @@ -15525,8 +18254,6 @@ func (ec *executionContext) _AftermarketDevice(ctx context.Context, sel ast.Sele } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "pairedAt": - out.Values[i] = ec._AftermarketDevice_pairedAt(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -15550,34 +18277,34 @@ func (ec *executionContext) _AftermarketDevice(ctx context.Context, sel ast.Sele return out } -var aftermarketDeviceConnectionImplementors = []string{"AftermarketDeviceConnection"} +var developerLicenseConnectionImplementors = []string{"DeveloperLicenseConnection"} -func (ec *executionContext) _AftermarketDeviceConnection(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceConnectionImplementors) +func (ec *executionContext) _DeveloperLicenseConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicenseConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("AftermarketDeviceConnection") + out.Values[i] = graphql.MarshalString("DeveloperLicenseConnection") case "totalCount": - out.Values[i] = ec._AftermarketDeviceConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._DeveloperLicenseConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._AftermarketDeviceConnection_edges(ctx, field, obj) + out.Values[i] = ec._DeveloperLicenseConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._AftermarketDeviceConnection_nodes(ctx, field, obj) + out.Values[i] = ec._DeveloperLicenseConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._AftermarketDeviceConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._DeveloperLicenseConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -15604,58 +18331,27 @@ func (ec *executionContext) _AftermarketDeviceConnection(ctx context.Context, se return out } -var aftermarketDeviceEarningsImplementors = []string{"AftermarketDeviceEarnings"} +var developerLicenseEdgeImplementors = []string{"DeveloperLicenseEdge"} -func (ec *executionContext) _AftermarketDeviceEarnings(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceEarnings) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceEarningsImplementors) +func (ec *executionContext) _DeveloperLicenseEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicenseEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("AftermarketDeviceEarnings") - case "totalTokens": - out.Values[i] = ec._AftermarketDeviceEarnings_totalTokens(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DeveloperLicenseEdge") + case "node": + out.Values[i] = ec._DeveloperLicenseEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "history": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._AftermarketDeviceEarnings_history(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res + out.Invalids++ } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue + case "cursor": + out.Values[i] = ec._DeveloperLicenseEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -15679,24 +18375,42 @@ func (ec *executionContext) _AftermarketDeviceEarnings(ctx context.Context, sel return out } -var aftermarketDeviceEdgeImplementors = []string{"AftermarketDeviceEdge"} +var deviceDefinitionImplementors = []string{"DeviceDefinition"} -func (ec *executionContext) _AftermarketDeviceEdge(ctx context.Context, sel ast.SelectionSet, obj *model.AftermarketDeviceEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, aftermarketDeviceEdgeImplementors) +func (ec *executionContext) _DeviceDefinition(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinition) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("AftermarketDeviceEdge") - case "cursor": - out.Values[i] = ec._AftermarketDeviceEdge_cursor(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DeviceDefinition") + case "deviceDefinitionId": + out.Values[i] = ec._DeviceDefinition_deviceDefinitionId(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "node": - out.Values[i] = ec._AftermarketDeviceEdge_node(ctx, field, obj) + case "legacyId": + out.Values[i] = ec._DeviceDefinition_legacyId(ctx, field, obj) + case "manufacturer": + out.Values[i] = ec._DeviceDefinition_manufacturer(ctx, field, obj) + case "model": + out.Values[i] = ec._DeviceDefinition_model(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "year": + out.Values[i] = ec._DeviceDefinition_year(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "deviceType": + out.Values[i] = ec._DeviceDefinition_deviceType(ctx, field, obj) + case "imageURI": + out.Values[i] = ec._DeviceDefinition_imageURI(ctx, field, obj) + case "attributes": + out.Values[i] = ec._DeviceDefinition_attributes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -15723,44 +18437,24 @@ func (ec *executionContext) _AftermarketDeviceEdge(ctx context.Context, sel ast. return out } -var connectionImplementors = []string{"Connection"} +var deviceDefinitionAttributeImplementors = []string{"DeviceDefinitionAttribute"} -func (ec *executionContext) _Connection(ctx context.Context, sel ast.SelectionSet, obj *model.Connection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, connectionImplementors) +func (ec *executionContext) _DeviceDefinitionAttribute(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionAttribute) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionAttributeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Connection") + out.Values[i] = graphql.MarshalString("DeviceDefinitionAttribute") case "name": - out.Values[i] = ec._Connection_name(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "address": - out.Values[i] = ec._Connection_address(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "owner": - out.Values[i] = ec._Connection_owner(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "tokenId": - out.Values[i] = ec._Connection_tokenId(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "tokenDID": - out.Values[i] = ec._Connection_tokenDID(ctx, field, obj) + out.Values[i] = ec._DeviceDefinitionAttribute_name(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "mintedAt": - out.Values[i] = ec._Connection_mintedAt(ctx, field, obj) + case "value": + out.Values[i] = ec._DeviceDefinitionAttribute_value(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -15787,34 +18481,34 @@ func (ec *executionContext) _Connection(ctx context.Context, sel ast.SelectionSe return out } -var connectionConnectionImplementors = []string{"ConnectionConnection"} +var deviceDefinitionConnectionImplementors = []string{"DeviceDefinitionConnection"} -func (ec *executionContext) _ConnectionConnection(ctx context.Context, sel ast.SelectionSet, obj *model.ConnectionConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, connectionConnectionImplementors) +func (ec *executionContext) _DeviceDefinitionConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConnectionConnection") + out.Values[i] = graphql.MarshalString("DeviceDefinitionConnection") case "totalCount": - out.Values[i] = ec._ConnectionConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._DeviceDefinitionConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._ConnectionConnection_edges(ctx, field, obj) + out.Values[i] = ec._DeviceDefinitionConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._ConnectionConnection_nodes(ctx, field, obj) + out.Values[i] = ec._DeviceDefinitionConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._ConnectionConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._DeviceDefinitionConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -15841,24 +18535,24 @@ func (ec *executionContext) _ConnectionConnection(ctx context.Context, sel ast.S return out } -var connectionEdgeImplementors = []string{"ConnectionEdge"} +var deviceDefinitionEdgeImplementors = []string{"DeviceDefinitionEdge"} -func (ec *executionContext) _ConnectionEdge(ctx context.Context, sel ast.SelectionSet, obj *model.ConnectionEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, connectionEdgeImplementors) +func (ec *executionContext) _DeviceDefinitionEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConnectionEdge") - case "node": - out.Values[i] = ec._ConnectionEdge_node(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DeviceDefinitionEdge") + case "cursor": + out.Values[i] = ec._DeviceDefinitionEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "cursor": - out.Values[i] = ec._ConnectionEdge_cursor(ctx, field, obj) + case "node": + out.Values[i] = ec._DeviceDefinitionEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -15885,51 +18579,110 @@ func (ec *executionContext) _ConnectionEdge(ctx context.Context, sel ast.Selecti return out } -var dCNImplementors = []string{"DCN", "Node"} +var earningImplementors = []string{"Earning"} -func (ec *executionContext) _DCN(ctx context.Context, sel ast.SelectionSet, obj *model.Dcn) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dCNImplementors) +func (ec *executionContext) _Earning(ctx context.Context, sel ast.SelectionSet, obj *model.Earning) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, earningImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DCN") - case "id": - out.Values[i] = ec._DCN_id(ctx, field, obj) + out.Values[i] = graphql.MarshalString("Earning") + case "week": + out.Values[i] = ec._Earning_week(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "node": - out.Values[i] = ec._DCN_node(ctx, field, obj) + case "beneficiary": + out.Values[i] = ec._Earning_beneficiary(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "tokenId": - out.Values[i] = ec._DCN_tokenId(ctx, field, obj) + case "connectionStreak": + out.Values[i] = ec._Earning_connectionStreak(ctx, field, obj) + case "streakTokens": + out.Values[i] = ec._Earning_streakTokens(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "tokenDID": - out.Values[i] = ec._DCN_tokenDID(ctx, field, obj) + case "aftermarketDevice": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Earning_aftermarketDevice(ctx, field, obj) + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "aftermarketDeviceTokens": + out.Values[i] = ec._Earning_aftermarketDeviceTokens(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "owner": - out.Values[i] = ec._DCN_owner(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + case "syntheticDevice": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Earning_syntheticDevice(ctx, field, obj) + return res } - case "expiresAt": - out.Values[i] = ec._DCN_expiresAt(ctx, field, obj) - case "mintedAt": - out.Values[i] = ec._DCN_mintedAt(ctx, field, obj) + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "syntheticDeviceTokens": + out.Values[i] = ec._Earning_syntheticDeviceTokens(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "name": - out.Values[i] = ec._DCN_name(ctx, field, obj) case "vehicle": field := field @@ -15939,7 +18692,7 @@ func (ec *executionContext) _DCN(ctx context.Context, sel ast.SelectionSet, obj ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._DCN_vehicle(ctx, field, obj) + res = ec._Earning_vehicle(ctx, field, obj) return res } @@ -15963,6 +18716,11 @@ func (ec *executionContext) _DCN(ctx context.Context, sel ast.SelectionSet, obj } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "sentAt": + out.Values[i] = ec._Earning_sentAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -15986,34 +18744,34 @@ func (ec *executionContext) _DCN(ctx context.Context, sel ast.SelectionSet, obj return out } -var dCNConnectionImplementors = []string{"DCNConnection"} +var earningsConnectionImplementors = []string{"EarningsConnection"} -func (ec *executionContext) _DCNConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DCNConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dCNConnectionImplementors) +func (ec *executionContext) _EarningsConnection(ctx context.Context, sel ast.SelectionSet, obj *model.EarningsConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, earningsConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DCNConnection") + out.Values[i] = graphql.MarshalString("EarningsConnection") case "totalCount": - out.Values[i] = ec._DCNConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._EarningsConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._DCNConnection_edges(ctx, field, obj) + out.Values[i] = ec._EarningsConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._DCNConnection_nodes(ctx, field, obj) + out.Values[i] = ec._EarningsConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._DCNConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._EarningsConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16040,24 +18798,24 @@ func (ec *executionContext) _DCNConnection(ctx context.Context, sel ast.Selectio return out } -var dCNEdgeImplementors = []string{"DCNEdge"} +var earningsEdgeImplementors = []string{"EarningsEdge"} -func (ec *executionContext) _DCNEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DCNEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dCNEdgeImplementors) +func (ec *executionContext) _EarningsEdge(ctx context.Context, sel ast.SelectionSet, obj *model.EarningsEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, earningsEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DCNEdge") - case "cursor": - out.Values[i] = ec._DCNEdge_cursor(ctx, field, obj) + out.Values[i] = graphql.MarshalString("EarningsEdge") + case "node": + out.Values[i] = ec._EarningsEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "node": - out.Values[i] = ec._DCNEdge_node(ctx, field, obj) + case "cursor": + out.Values[i] = ec._EarningsEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16084,87 +18842,50 @@ func (ec *executionContext) _DCNEdge(ctx context.Context, sel ast.SelectionSet, return out } -var definitionImplementors = []string{"Definition"} +var manufacturerImplementors = []string{"Manufacturer", "Node"} -func (ec *executionContext) _Definition(ctx context.Context, sel ast.SelectionSet, obj *model.Definition) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, definitionImplementors) +func (ec *executionContext) _Manufacturer(ctx context.Context, sel ast.SelectionSet, obj *model.Manufacturer) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Definition") + out.Values[i] = graphql.MarshalString("Manufacturer") case "id": - out.Values[i] = ec._Definition_id(ctx, field, obj) - case "make": - out.Values[i] = ec._Definition_make(ctx, field, obj) - case "model": - out.Values[i] = ec._Definition_model(ctx, field, obj) - case "year": - out.Values[i] = ec._Definition_year(ctx, field, obj) - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.ProcessDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var developerLicenseImplementors = []string{"DeveloperLicense"} - -func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicense) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("DeveloperLicense") + out.Values[i] = ec._Manufacturer_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } case "tokenId": - out.Values[i] = ec._DeveloperLicense_tokenId(ctx, field, obj) + out.Values[i] = ec._Manufacturer_tokenId(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } case "tokenDID": - out.Values[i] = ec._DeveloperLicense_tokenDID(ctx, field, obj) + out.Values[i] = ec._Manufacturer_tokenDID(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "owner": - out.Values[i] = ec._DeveloperLicense_owner(ctx, field, obj) + case "name": + out.Values[i] = ec._Manufacturer_name(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "clientId": - out.Values[i] = ec._DeveloperLicense_clientId(ctx, field, obj) + case "owner": + out.Values[i] = ec._Manufacturer_owner(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "alias": - out.Values[i] = ec._DeveloperLicense_alias(ctx, field, obj) + case "tableId": + out.Values[i] = ec._Manufacturer_tableId(ctx, field, obj) case "mintedAt": - out.Values[i] = ec._DeveloperLicense_mintedAt(ctx, field, obj) + out.Values[i] = ec._Manufacturer_mintedAt(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "signers": + case "aftermarketDevices": field := field innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { @@ -16173,7 +18894,7 @@ func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.Selec ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._DeveloperLicense_signers(ctx, field, obj) + res = ec._Manufacturer_aftermarketDevices(ctx, field, obj) if res == graphql.Null { atomic.AddUint32(&fs.Invalids, 1) } @@ -16200,7 +18921,7 @@ func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.Selec } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "redirectURIs": + case "deviceDefinitions": field := field innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { @@ -16209,7 +18930,7 @@ func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.Selec ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._DeveloperLicense_redirectURIs(ctx, field, obj) + res = ec._Manufacturer_deviceDefinitions(ctx, field, obj) if res == graphql.Null { atomic.AddUint32(&fs.Invalids, 1) } @@ -16259,34 +18980,34 @@ func (ec *executionContext) _DeveloperLicense(ctx context.Context, sel ast.Selec return out } -var developerLicenseConnectionImplementors = []string{"DeveloperLicenseConnection"} +var manufacturerConnectionImplementors = []string{"ManufacturerConnection"} -func (ec *executionContext) _DeveloperLicenseConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicenseConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseConnectionImplementors) +func (ec *executionContext) _ManufacturerConnection(ctx context.Context, sel ast.SelectionSet, obj *model.ManufacturerConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DeveloperLicenseConnection") + out.Values[i] = graphql.MarshalString("ManufacturerConnection") case "totalCount": - out.Values[i] = ec._DeveloperLicenseConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._ManufacturerConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._DeveloperLicenseConnection_edges(ctx, field, obj) + out.Values[i] = ec._ManufacturerConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._DeveloperLicenseConnection_nodes(ctx, field, obj) + out.Values[i] = ec._ManufacturerConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._DeveloperLicenseConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._ManufacturerConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16313,86 +19034,24 @@ func (ec *executionContext) _DeveloperLicenseConnection(ctx context.Context, sel return out } -var developerLicenseEdgeImplementors = []string{"DeveloperLicenseEdge"} +var manufacturerEdgeImplementors = []string{"ManufacturerEdge"} -func (ec *executionContext) _DeveloperLicenseEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DeveloperLicenseEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, developerLicenseEdgeImplementors) +func (ec *executionContext) _ManufacturerEdge(ctx context.Context, sel ast.SelectionSet, obj *model.ManufacturerEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DeveloperLicenseEdge") + out.Values[i] = graphql.MarshalString("ManufacturerEdge") case "node": - out.Values[i] = ec._DeveloperLicenseEdge_node(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "cursor": - out.Values[i] = ec._DeveloperLicenseEdge_cursor(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.Deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.ProcessDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var deviceDefinitionImplementors = []string{"DeviceDefinition"} - -func (ec *executionContext) _DeviceDefinition(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinition) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("DeviceDefinition") - case "deviceDefinitionId": - out.Values[i] = ec._DeviceDefinition_deviceDefinitionId(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "legacyId": - out.Values[i] = ec._DeviceDefinition_legacyId(ctx, field, obj) - case "manufacturer": - out.Values[i] = ec._DeviceDefinition_manufacturer(ctx, field, obj) - case "model": - out.Values[i] = ec._DeviceDefinition_model(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "year": - out.Values[i] = ec._DeviceDefinition_year(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "deviceType": - out.Values[i] = ec._DeviceDefinition_deviceType(ctx, field, obj) - case "imageURI": - out.Values[i] = ec._DeviceDefinition_imageURI(ctx, field, obj) - case "attributes": - out.Values[i] = ec._DeviceDefinition_attributes(ctx, field, obj) + out.Values[i] = ec._ManufacturerEdge_node(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "cursor": + out.Values[i] = ec._ManufacturerEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16419,24 +19078,54 @@ func (ec *executionContext) _DeviceDefinition(ctx context.Context, sel ast.Selec return out } -var deviceDefinitionAttributeImplementors = []string{"DeviceDefinitionAttribute"} +var merkleEpochImplementors = []string{"MerkleEpoch"} -func (ec *executionContext) _DeviceDefinitionAttribute(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionAttribute) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionAttributeImplementors) +func (ec *executionContext) _MerkleEpoch(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleEpoch) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleEpochImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DeviceDefinitionAttribute") - case "name": - out.Values[i] = ec._DeviceDefinitionAttribute_name(ctx, field, obj) + out.Values[i] = graphql.MarshalString("MerkleEpoch") + case "epoch": + out.Values[i] = ec._MerkleEpoch_epoch(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "value": - out.Values[i] = ec._DeviceDefinitionAttribute_value(ctx, field, obj) + case "root": + out.Values[i] = ec._MerkleEpoch_root(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "allocation": + out.Values[i] = ec._MerkleEpoch_allocation(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "totalClaimed": + out.Values[i] = ec._MerkleEpoch_totalClaimed(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "claimCount": + out.Values[i] = ec._MerkleEpoch_claimCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "recipientCount": + out.Values[i] = ec._MerkleEpoch_recipientCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "proofsURI": + out.Values[i] = ec._MerkleEpoch_proofsURI(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "setAt": + out.Values[i] = ec._MerkleEpoch_setAt(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16463,34 +19152,34 @@ func (ec *executionContext) _DeviceDefinitionAttribute(ctx context.Context, sel return out } -var deviceDefinitionConnectionImplementors = []string{"DeviceDefinitionConnection"} +var merkleEpochConnectionImplementors = []string{"MerkleEpochConnection"} -func (ec *executionContext) _DeviceDefinitionConnection(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionConnectionImplementors) +func (ec *executionContext) _MerkleEpochConnection(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleEpochConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleEpochConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DeviceDefinitionConnection") + out.Values[i] = graphql.MarshalString("MerkleEpochConnection") case "totalCount": - out.Values[i] = ec._DeviceDefinitionConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._MerkleEpochConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._DeviceDefinitionConnection_edges(ctx, field, obj) + out.Values[i] = ec._MerkleEpochConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._DeviceDefinitionConnection_nodes(ctx, field, obj) + out.Values[i] = ec._MerkleEpochConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._DeviceDefinitionConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._MerkleEpochConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16517,24 +19206,24 @@ func (ec *executionContext) _DeviceDefinitionConnection(ctx context.Context, sel return out } -var deviceDefinitionEdgeImplementors = []string{"DeviceDefinitionEdge"} +var merkleEpochEdgeImplementors = []string{"MerkleEpochEdge"} -func (ec *executionContext) _DeviceDefinitionEdge(ctx context.Context, sel ast.SelectionSet, obj *model.DeviceDefinitionEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, deviceDefinitionEdgeImplementors) +func (ec *executionContext) _MerkleEpochEdge(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleEpochEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleEpochEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("DeviceDefinitionEdge") - case "cursor": - out.Values[i] = ec._DeviceDefinitionEdge_cursor(ctx, field, obj) + out.Values[i] = graphql.MarshalString("MerkleEpochEdge") + case "node": + out.Values[i] = ec._MerkleEpochEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "node": - out.Values[i] = ec._DeviceDefinitionEdge_node(ctx, field, obj) + case "cursor": + out.Values[i] = ec._MerkleEpochEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16561,120 +19250,57 @@ func (ec *executionContext) _DeviceDefinitionEdge(ctx context.Context, sel ast.S return out } -var earningImplementors = []string{"Earning"} +var merklePoolImplementors = []string{"MerklePool"} -func (ec *executionContext) _Earning(ctx context.Context, sel ast.SelectionSet, obj *model.Earning) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, earningImplementors) +func (ec *executionContext) _MerklePool(ctx context.Context, sel ast.SelectionSet, obj *model.MerklePool) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merklePoolImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Earning") - case "week": - out.Values[i] = ec._Earning_week(ctx, field, obj) + out.Values[i] = graphql.MarshalString("MerklePool") + case "poolId": + out.Values[i] = ec._MerklePool_poolId(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "beneficiary": - out.Values[i] = ec._Earning_beneficiary(ctx, field, obj) + case "token": + out.Values[i] = ec._MerklePool_token(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "connectionStreak": - out.Values[i] = ec._Earning_connectionStreak(ctx, field, obj) - case "streakTokens": - out.Values[i] = ec._Earning_streakTokens(ctx, field, obj) + case "admin": + out.Values[i] = ec._MerklePool_admin(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "aftermarketDevice": - field := field - - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Earning_aftermarketDevice(ctx, field, obj) - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue - } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "aftermarketDeviceTokens": - out.Values[i] = ec._Earning_aftermarketDeviceTokens(ctx, field, obj) + case "weeklyLimit": + out.Values[i] = ec._MerklePool_weeklyLimit(ctx, field, obj) + case "balance": + out.Values[i] = ec._MerklePool_balance(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "syntheticDevice": - field := field - - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Earning_syntheticDevice(ctx, field, obj) - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue - } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "syntheticDeviceTokens": - out.Values[i] = ec._Earning_syntheticDeviceTokens(ctx, field, obj) + case "createdAt": + out.Values[i] = ec._MerklePool_createdAt(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "vehicle": + case "epochs": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Earning_vehicle(ctx, field, obj) + res = ec._MerklePool_epochs(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } return res } @@ -16698,11 +19324,6 @@ func (ec *executionContext) _Earning(ctx context.Context, sel ast.SelectionSet, } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "sentAt": - out.Values[i] = ec._Earning_sentAt(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -16726,34 +19347,34 @@ func (ec *executionContext) _Earning(ctx context.Context, sel ast.SelectionSet, return out } -var earningsConnectionImplementors = []string{"EarningsConnection"} +var merklePoolConnectionImplementors = []string{"MerklePoolConnection"} -func (ec *executionContext) _EarningsConnection(ctx context.Context, sel ast.SelectionSet, obj *model.EarningsConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, earningsConnectionImplementors) +func (ec *executionContext) _MerklePoolConnection(ctx context.Context, sel ast.SelectionSet, obj *model.MerklePoolConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merklePoolConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("EarningsConnection") + out.Values[i] = graphql.MarshalString("MerklePoolConnection") case "totalCount": - out.Values[i] = ec._EarningsConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._MerklePoolConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._EarningsConnection_edges(ctx, field, obj) + out.Values[i] = ec._MerklePoolConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._EarningsConnection_nodes(ctx, field, obj) + out.Values[i] = ec._MerklePoolConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._EarningsConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._MerklePoolConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16780,24 +19401,24 @@ func (ec *executionContext) _EarningsConnection(ctx context.Context, sel ast.Sel return out } -var earningsEdgeImplementors = []string{"EarningsEdge"} +var merklePoolEdgeImplementors = []string{"MerklePoolEdge"} -func (ec *executionContext) _EarningsEdge(ctx context.Context, sel ast.SelectionSet, obj *model.EarningsEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, earningsEdgeImplementors) +func (ec *executionContext) _MerklePoolEdge(ctx context.Context, sel ast.SelectionSet, obj *model.MerklePoolEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merklePoolEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("EarningsEdge") + out.Values[i] = graphql.MarshalString("MerklePoolEdge") case "node": - out.Values[i] = ec._EarningsEdge_node(ctx, field, obj) + out.Values[i] = ec._MerklePoolEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "cursor": - out.Values[i] = ec._EarningsEdge_cursor(ctx, field, obj) + out.Values[i] = ec._MerklePoolEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -16824,50 +19445,18 @@ func (ec *executionContext) _EarningsEdge(ctx context.Context, sel ast.Selection return out } -var manufacturerImplementors = []string{"Manufacturer", "Node"} +var merkleRewardImplementors = []string{"MerkleReward"} -func (ec *executionContext) _Manufacturer(ctx context.Context, sel ast.SelectionSet, obj *model.Manufacturer) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerImplementors) +func (ec *executionContext) _MerkleReward(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleReward) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleRewardImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Manufacturer") - case "id": - out.Values[i] = ec._Manufacturer_id(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "tokenId": - out.Values[i] = ec._Manufacturer_tokenId(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "tokenDID": - out.Values[i] = ec._Manufacturer_tokenDID(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "name": - out.Values[i] = ec._Manufacturer_name(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "owner": - out.Values[i] = ec._Manufacturer_owner(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "tableId": - out.Values[i] = ec._Manufacturer_tableId(ctx, field, obj) - case "mintedAt": - out.Values[i] = ec._Manufacturer_mintedAt(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "aftermarketDevices": + out.Values[i] = graphql.MarshalString("MerkleReward") + case "pool": field := field innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { @@ -16876,7 +19465,7 @@ func (ec *executionContext) _Manufacturer(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Manufacturer_aftermarketDevices(ctx, field, obj) + res = ec._MerkleReward_pool(ctx, field, obj) if res == graphql.Null { atomic.AddUint32(&fs.Invalids, 1) } @@ -16903,42 +19492,35 @@ func (ec *executionContext) _Manufacturer(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "deviceDefinitions": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._Manufacturer_deviceDefinitions(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res + case "epoch": + out.Values[i] = ec._MerkleReward_epoch(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue + case "account": + out.Values[i] = ec._MerkleReward_account(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "amount": + out.Values[i] = ec._MerkleReward_amount(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "proof": + out.Values[i] = ec._MerkleReward_proof(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "claimed": + out.Values[i] = ec._MerkleReward_claimed(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "claimedAt": + out.Values[i] = ec._MerkleReward_claimedAt(ctx, field, obj) + case "claimTx": + out.Values[i] = ec._MerkleReward_claimTx(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -16962,34 +19544,34 @@ func (ec *executionContext) _Manufacturer(ctx context.Context, sel ast.Selection return out } -var manufacturerConnectionImplementors = []string{"ManufacturerConnection"} +var merkleRewardConnectionImplementors = []string{"MerkleRewardConnection"} -func (ec *executionContext) _ManufacturerConnection(ctx context.Context, sel ast.SelectionSet, obj *model.ManufacturerConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerConnectionImplementors) +func (ec *executionContext) _MerkleRewardConnection(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleRewardConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleRewardConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ManufacturerConnection") + out.Values[i] = graphql.MarshalString("MerkleRewardConnection") case "totalCount": - out.Values[i] = ec._ManufacturerConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._MerkleRewardConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "edges": - out.Values[i] = ec._ManufacturerConnection_edges(ctx, field, obj) + out.Values[i] = ec._MerkleRewardConnection_edges(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "nodes": - out.Values[i] = ec._ManufacturerConnection_nodes(ctx, field, obj) + out.Values[i] = ec._MerkleRewardConnection_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "pageInfo": - out.Values[i] = ec._ManufacturerConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._MerkleRewardConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -17016,24 +19598,24 @@ func (ec *executionContext) _ManufacturerConnection(ctx context.Context, sel ast return out } -var manufacturerEdgeImplementors = []string{"ManufacturerEdge"} +var merkleRewardEdgeImplementors = []string{"MerkleRewardEdge"} -func (ec *executionContext) _ManufacturerEdge(ctx context.Context, sel ast.SelectionSet, obj *model.ManufacturerEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, manufacturerEdgeImplementors) +func (ec *executionContext) _MerkleRewardEdge(ctx context.Context, sel ast.SelectionSet, obj *model.MerkleRewardEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, merkleRewardEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ManufacturerEdge") + out.Values[i] = graphql.MarshalString("MerkleRewardEdge") case "node": - out.Values[i] = ec._ManufacturerEdge_node(ctx, field, obj) + out.Values[i] = ec._MerkleRewardEdge_node(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "cursor": - out.Values[i] = ec._ManufacturerEdge_cursor(ctx, field, obj) + out.Values[i] = ec._MerkleRewardEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -17521,6 +20103,69 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "merklePools": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_merklePools(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "merklePool": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_merklePool(ctx, field) + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "merkleRewards": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_merkleRewards(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "rewards": field := field @@ -20548,6 +23193,208 @@ func (ec *executionContext) marshalNManufacturerEdge2ᚖgithubᚗcomᚋDIMOᚑNe return ec._ManufacturerEdge(ctx, sel, v) } +func (ec *executionContext) marshalNMerkleEpoch2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerkleEpoch) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerkleEpoch2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpoch(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerkleEpoch2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpoch(ctx context.Context, sel ast.SelectionSet, v *model.MerkleEpoch) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleEpoch(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerkleEpochConnection2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochConnection(ctx context.Context, sel ast.SelectionSet, v model.MerkleEpochConnection) graphql.Marshaler { + return ec._MerkleEpochConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNMerkleEpochConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochConnection(ctx context.Context, sel ast.SelectionSet, v *model.MerkleEpochConnection) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleEpochConnection(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerkleEpochEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerkleEpochEdge) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerkleEpochEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochEdge(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerkleEpochEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleEpochEdge(ctx context.Context, sel ast.SelectionSet, v *model.MerkleEpochEdge) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleEpochEdge(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerklePool2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool(ctx context.Context, sel ast.SelectionSet, v model.MerklePool) graphql.Marshaler { + return ec._MerklePool(ctx, sel, &v) +} + +func (ec *executionContext) marshalNMerklePool2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerklePool) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool(ctx context.Context, sel ast.SelectionSet, v *model.MerklePool) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerklePool(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerklePoolConnection2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolConnection(ctx context.Context, sel ast.SelectionSet, v model.MerklePoolConnection) graphql.Marshaler { + return ec._MerklePoolConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNMerklePoolConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolConnection(ctx context.Context, sel ast.SelectionSet, v *model.MerklePoolConnection) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerklePoolConnection(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerklePoolEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerklePoolEdge) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerklePoolEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolEdge(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerklePoolEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePoolEdge(ctx context.Context, sel ast.SelectionSet, v *model.MerklePoolEdge) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerklePoolEdge(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerkleReward2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerkleReward) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerkleReward2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleReward(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerkleReward2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleReward(ctx context.Context, sel ast.SelectionSet, v *model.MerkleReward) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleReward(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerkleRewardConnection2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardConnection(ctx context.Context, sel ast.SelectionSet, v model.MerkleRewardConnection) graphql.Marshaler { + return ec._MerkleRewardConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNMerkleRewardConnection2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardConnection(ctx context.Context, sel ast.SelectionSet, v *model.MerkleRewardConnection) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleRewardConnection(ctx, sel, v) +} + +func (ec *executionContext) marshalNMerkleRewardEdge2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MerkleRewardEdge) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNMerkleRewardEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardEdge(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNMerkleRewardEdge2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerkleRewardEdge(ctx context.Context, sel ast.SelectionSet, v *model.MerkleRewardEdge) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._MerkleRewardEdge(ctx, sel, v) +} + func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *model.PageInfo) graphql.Marshaler { if v == nil { if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { @@ -20890,6 +23737,36 @@ func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.S return res } +func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) { + var vSlice []any + vSlice = graphql.CoerceList(v) + var err error + res := make([]string, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNString2string(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler { + ret := make(graphql.Array, len(v)) + for i := range v { + ret[i] = ec.marshalNString2string(ctx, sel, v[i]) + } + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + func (ec *executionContext) marshalNSyntheticDevice2ᚕᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐSyntheticDeviceᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.SyntheticDevice) graphql.Marshaler { ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { fc := graphql.GetFieldContext(ctx) @@ -21456,6 +24333,13 @@ func (ec *executionContext) marshalOManufacturer2ᚖgithubᚗcomᚋDIMOᚑNetwor return ec._Manufacturer(ctx, sel, v) } +func (ec *executionContext) marshalOMerklePool2ᚖgithubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐMerklePool(ctx context.Context, sel ast.SelectionSet, v *model.MerklePool) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._MerklePool(ctx, sel, v) +} + func (ec *executionContext) marshalONode2githubᚗcomᚋDIMOᚑNetworkᚋidentityᚑapiᚋgraphᚋmodelᚐNode(ctx context.Context, sel ast.SelectionSet, v model.Node) graphql.Marshaler { if v == nil { return graphql.Null diff --git a/graph/mcp_tools_gen.go b/graph/mcp_tools_gen.go index 30c76168..840866d2 100644 --- a/graph/mcp_tools_gen.go +++ b/graph/mcp_tools_gen.go @@ -58,4 +58,4 @@ var MCPTools = []mcpserver.ToolDefinition{ }, } -var CondensedSchema = "scalar Address # A 20-byte Ethereum address, encoded as a checksummed hex string with 0x prefix.\nscalar BigDecimal # BigDecimal decimal floating-point number, per the General Decimal Arithmetic specification.\nscalar BigInt # An integer of arbitrary precision, decimal-encoded.\nscalar Bytes # An array of byte, encoded as a lowercase hex string with 0x prefix.\nscalar Time # A point in time, encoded per RFC-3999.\n\n# All tokenDID fields use the format did:erc721:::\n# All *Edge types: { node: T!, cursor: String! }\n# All *Connection types: { totalCount: Int!, edges: [TEdge!]!, nodes: [T!]!, pageInfo: PageInfo! }\n\ntype Query {\n node(id: ID!): Node\n aftermarketDevice(by: AftermarketDeviceBy!): AftermarketDevice\n # Example - Get aftermarket device by serial:\n # { aftermarketDevice(by: { serial: \"abc-123\" }) { tokenId owner serial manufacturer { name } vehicle { tokenId definition { make model year } } earnings { totalTokens } } }\n\n aftermarketDevices(first: Int, after: String, last: Int, before: String, filterBy: AftermarketDevicesFilter): AftermarketDeviceConnection!\n connections(first: Int, after: String, last: Int, before: String): ConnectionConnection!\n connection(by: ConnectionBy!): Connection\n dcn(by: DCNBy!): DCN\n dcns(first: Int, after: String, last: Int, before: String, filterBy: DCNFilter): DCNConnection!\n developerLicenses(first: Int, after: String, last: Int, before: String, filterBy: DeveloperLicenseFilterBy): DeveloperLicenseConnection!\n developerLicense(by: DeveloperLicenseBy!): DeveloperLicense\n deviceDefinition(by: DeviceDefinitionBy!): DeviceDefinition\n manufacturer(by: ManufacturerBy!): Manufacturer\n manufacturers: ManufacturerConnection!\n rewards(user: Address!): UserRewards\n stakes(first: Int, after: String, last: Int, before: String, filterBy: StakeFilterBy): StakeConnection\n syntheticDevice(by: SyntheticDeviceBy!): SyntheticDevice\n syntheticDevices(first: Int, last: Int, after: String, before: String, filterBy: SyntheticDevicesFilter): SyntheticDeviceConnection!\n template(by: TemplateBy!): Template\n templates(first: Int, after: String, last: Int, before: String): TemplateConnection!\n account(by: AccountBy!): Account\n vehicle(tokenId: Int, tokenDID: String): Vehicle\n # Example - Get vehicle by tokenId:\n # { vehicle(tokenId: 123) { tokenId name owner definition { make model year } aftermarketDevice { serial } syntheticDevice { tokenId } dcn { name } stake { level amount } } }\n # Example - Get vehicle SACDs (permission grants):\n # { vehicle(tokenId: 123) { sacds { nodes { grantee permissions expiresAt template { cid } } } } }\n # Example - Get vehicle privileges:\n # { vehicle(tokenId: 123) { privileges(filterBy: { user: \"0x...\" }) { nodes { id user setAt expiresAt } } } }\n\n vehicles(first: Int, after: String, last: Int, before: String, filterBy: VehiclesFilter): VehicleConnection!\n # Example - List vehicles user has access to (via privileges or SACDs):\n # { vehicles(first: 100, filterBy: { privileged: \"0x...\" }) { nodes { tokenId name owner } } }\n}\n\ntype Account { address: Address!, sacds(first: Int, after: String, last: Int, before: String): SacdConnection! }\n\ninput AccountBy @oneOf { address: Address }\n\ntype AftermarketDevice implements Node { id: ID!, tokenId: Int!, tokenDID: String!, manufacturer: Manufacturer!, address: Address!, owner: Address!, serial: String, imei: String, devEUI: String, hardwareRevision: String, mintedAt: Time!, claimedAt: Time, vehicle: Vehicle, beneficiary: Address!, name: String!, image: String!, earnings: AftermarketDeviceEarnings, pairedAt: Time }\n\ninput AftermarketDeviceBy @oneOf {\n \"token id of the aftermarket device NFT\"\n tokenId: Int\n tokenDID: String\n address: Address\n \"serial number of the aftermarket device\"\n serial: String\n \"The International Mobile Equipment Identity (IMEI) for the device if available\"\n imei: String\n \"Extended Unique Identifier (EUI) for LoRa devices if available\"\n devEUI: String\n}\n\ntype AftermarketDeviceEarnings { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ninput AftermarketDevicesFilter { owner: Address, beneficiary: Address, manufacturerId: Int }\n\ntype Connection { name: String!, address: Address!, owner: Address!, tokenId: BigInt!, tokenDID: String!, mintedAt: Time! }\n\ninput ConnectionBy { name: String, address: Address, tokenId: BigInt, tokenDID: String }\n\ntype DCN implements Node { id: ID!, node: Bytes!, tokenId: BigInt!, tokenDID: String!, owner: Address!, expiresAt: Time, mintedAt: Time!, name: String, vehicle: Vehicle }\n\ninput DCNBy @oneOf { node: Bytes, tokenDID: String, name: String }\n\ninput DCNFilter { owner: Address }\n\ntype Definition { id: String, make: String, model: String, year: Int }\n\ntype DeveloperLicense { tokenId: Int!, tokenDID: String!, owner: Address!, clientId: Address!, alias: String, mintedAt: Time!, signers(first: Int, after: String, last: Int, before: String): SignerConnection!, redirectURIs(first: Int, after: String, last: Int, before: String): RedirectURIConnection! }\n\ninput DeveloperLicenseBy { clientId: Address, alias: String, tokenId: Int, tokenDID: String }\n\ninput DeveloperLicenseFilterBy { signer: Address, owner: Address }\n\ntype DeviceDefinition { deviceDefinitionId: String!, legacyId: String, manufacturer: Manufacturer, model: String!, year: Int!, deviceType: String, imageURI: String, attributes: [DeviceDefinitionAttribute!]! }\n\ntype DeviceDefinitionAttribute { name: String!, value: String! }\n\ninput DeviceDefinitionBy @oneOf { id: String! }\n\ninput DeviceDefinitionFilter {\n \"Model filters for device definition that are of the given model. This filter performs a case insensitive match.\"\n model: String\n \"Year filters for device definition that are of the given year.\"\n year: Int\n}\n\ntype Earning { week: Int!, beneficiary: Address!, connectionStreak: Int, streakTokens: BigDecimal!, aftermarketDevice: AftermarketDevice, aftermarketDeviceTokens: BigDecimal!, syntheticDevice: SyntheticDevice, syntheticDeviceTokens: BigDecimal!, vehicle: Vehicle, sentAt: Time! }\n\ntype Manufacturer implements Node { id: ID!, tokenId: Int!, tokenDID: String!, name: String!, owner: Address!, tableId: Int, mintedAt: Time!, aftermarketDevices(first: Int, after: String, last: Int, before: String, filterBy: AftermarketDevicesFilter): AftermarketDeviceConnection!, deviceDefinitions(first: Int, after: String, last: Int, before: String, filterBy: DeviceDefinitionFilter): DeviceDefinitionConnection! }\n\ninput ManufacturerBy @oneOf { name: String, tokenId: Int, slug: String, tokenDID: String }\n\ninterface Node { id: ID! }\n\ntype PageInfo { startCursor: String, endCursor: String, hasPreviousPage: Boolean!, hasNextPage: Boolean! }\n\ntype Privilege { id: Int!, user: Address!, setAt: Time!, expiresAt: Time! }\n\ninput PrivilegeFilterBy { user: Address, privilegeId: Int }\n\ntype RedirectURI { uri: String!, enabledAt: Time! }\n\ntype Sacd { grantee: Address!, permissions: String!, source: String!, createdAt: Time!, expiresAt: Time!, template: Template }\n\ntype Signer { address: Address!, enabledAt: Time! }\n\ntype Stake { tokenId: Int!, tokenDID: String!, owner: Address!, level: Int!, points: Int!, amount: BigDecimal!, stakedAt: Time!, endsAt: Time!, withdrawnAt: Time, vehicle: Vehicle }\n\ninput StakeFilterBy {\n owner: Address\n \"Filter stakes based on attachability. A stake is considered attachable if it is not presently attached to a vehicle and has not yet ended.\"\n attachable: Boolean\n}\n\ntype StorageNode { label: String!, address: Address!, owner: Address!, tokenId: BigInt!, uri: String!, tokenDID: String!, mintedAt: Time! }\n\ntype SyntheticDevice implements Node { id: ID!, name: String!, tokenId: Int!, tokenDID: String!, address: Address!, mintedAt: Time!, vehicle: Vehicle!, connection: Connection! }\n\ninput SyntheticDeviceBy @oneOf {\n tokenId: Int\n tokenDID: String\n \"The Ethereum address for the synthetic device.\"\n address: Address\n}\n\ninput SyntheticDevicesFilter { owner: Address, integrationId: Int }\n\ntype Template { tokenId: BigInt!, creator: Address!, asset: Address!, permissions: String!, cid: String!, createdAt: Time! }\n\ninput TemplateBy { tokenId: BigInt, cid: String }\n\ntype UserRewards { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ntype Vehicle implements Node { id: ID!, tokenId: Int!, tokenDID: String!, manufacturer: Manufacturer!, owner: Address!, mintedAt: Time!, aftermarketDevice: AftermarketDevice, privileges(first: Int, after: String, last: Int, before: String, filterBy: PrivilegeFilterBy): PrivilegesConnection!, sacds(first: Int, after: String, last: Int, before: String): SacdConnection!, sacd(grantee: Address!): Sacd, syntheticDevice: SyntheticDevice, definition: Definition, dcn: DCN, name: String!, imageURI: String!, earnings: VehicleEarnings, dataURI: String!, stake: Stake, storageNode: StorageNode }\n\ntype VehicleEarnings { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ninput VehiclesFilter {\n \"Privileged filters for vehicles to which the given address has access. This includes vehicles that this address owns.\"\n privileged: Address\n owner: Address\n \"Make filters for vehicles that are of the given make.\"\n make: String\n \"Model filters for vehicles that are of the given model.\"\n model: String\n \"Year filters for vehicles that are of the given year.\"\n year: Int\n \"Filter for vehicles produced by a particular manufacturer, specified by manufacturer token id.\"\n manufacturerTokenId: Int\n deviceDefinitionId: String\n}\n" +var CondensedSchema = "scalar Address # A 20-byte Ethereum address, encoded as a checksummed hex string with 0x prefix.\nscalar BigDecimal # BigDecimal decimal floating-point number, per the General Decimal Arithmetic specification.\nscalar BigInt # An integer of arbitrary precision, decimal-encoded.\nscalar Bytes # An array of byte, encoded as a lowercase hex string with 0x prefix.\nscalar Time # A point in time, encoded per RFC-3999.\n\n# All tokenDID fields use the format did:erc721:::\n# All *Edge types: { node: T!, cursor: String! }\n# All *Connection types: { totalCount: Int!, edges: [TEdge!]!, nodes: [T!]!, pageInfo: PageInfo! }\n\ntype Query {\n node(id: ID!): Node\n aftermarketDevice(by: AftermarketDeviceBy!): AftermarketDevice\n # Example - Get aftermarket device by serial:\n # { aftermarketDevice(by: { serial: \"abc-123\" }) { tokenId owner serial manufacturer { name } vehicle { tokenId definition { make model year } } earnings { totalTokens } } }\n\n aftermarketDevices(first: Int, after: String, last: Int, before: String, filterBy: AftermarketDevicesFilter): AftermarketDeviceConnection!\n connections(first: Int, after: String, last: Int, before: String): ConnectionConnection!\n connection(by: ConnectionBy!): Connection\n dcn(by: DCNBy!): DCN\n dcns(first: Int, after: String, last: Int, before: String, filterBy: DCNFilter): DCNConnection!\n developerLicenses(first: Int, after: String, last: Int, before: String, filterBy: DeveloperLicenseFilterBy): DeveloperLicenseConnection!\n developerLicense(by: DeveloperLicenseBy!): DeveloperLicense\n deviceDefinition(by: DeviceDefinitionBy!): DeviceDefinition\n manufacturer(by: ManufacturerBy!): Manufacturer\n manufacturers: ManufacturerConnection!\n merklePools(first: Int, after: String, last: Int, before: String): MerklePoolConnection!\n merklePool(poolId: Int!): MerklePool\n merkleRewards(\n \"The account to which the rewards were allocated.\"\n account: Address!\n \"If provided, only return rewards from this pool.\"\n poolId: Int\n \"If provided, only return rewards that have (true) or have not (false) been claimed.\"\n claimed: Boolean\n first: Int\n after: String\n last: Int\n before: String\n ): MerkleRewardConnection!\n rewards(user: Address!): UserRewards\n stakes(first: Int, after: String, last: Int, before: String, filterBy: StakeFilterBy): StakeConnection\n syntheticDevice(by: SyntheticDeviceBy!): SyntheticDevice\n syntheticDevices(first: Int, last: Int, after: String, before: String, filterBy: SyntheticDevicesFilter): SyntheticDeviceConnection!\n template(by: TemplateBy!): Template\n templates(first: Int, after: String, last: Int, before: String): TemplateConnection!\n account(by: AccountBy!): Account\n vehicle(tokenId: Int, tokenDID: String): Vehicle\n # Example - Get vehicle by tokenId:\n # { vehicle(tokenId: 123) { tokenId name owner definition { make model year } aftermarketDevice { serial } syntheticDevice { tokenId } dcn { name } stake { level amount } } }\n # Example - Get vehicle SACDs (permission grants):\n # { vehicle(tokenId: 123) { sacds { nodes { grantee permissions expiresAt template { cid } } } } }\n # Example - Get vehicle privileges:\n # { vehicle(tokenId: 123) { privileges(filterBy: { user: \"0x...\" }) { nodes { id user setAt expiresAt } } } }\n\n vehicles(first: Int, after: String, last: Int, before: String, filterBy: VehiclesFilter): VehicleConnection!\n # Example - List vehicles user has access to (via privileges or SACDs):\n # { vehicles(first: 100, filterBy: { privileged: \"0x...\" }) { nodes { tokenId name owner } } }\n}\n\ntype Account { address: Address!, sacds(first: Int, after: String, last: Int, before: String): SacdConnection! }\n\ninput AccountBy @oneOf { address: Address }\n\ntype AftermarketDevice implements Node { id: ID!, tokenId: Int!, tokenDID: String!, manufacturer: Manufacturer!, address: Address!, owner: Address!, serial: String, imei: String, devEUI: String, hardwareRevision: String, mintedAt: Time!, claimedAt: Time, vehicle: Vehicle, beneficiary: Address!, name: String!, image: String!, earnings: AftermarketDeviceEarnings, pairedAt: Time }\n\ninput AftermarketDeviceBy @oneOf {\n \"token id of the aftermarket device NFT\"\n tokenId: Int\n tokenDID: String\n address: Address\n \"serial number of the aftermarket device\"\n serial: String\n \"The International Mobile Equipment Identity (IMEI) for the device if available\"\n imei: String\n \"Extended Unique Identifier (EUI) for LoRa devices if available\"\n devEUI: String\n}\n\ntype AftermarketDeviceEarnings { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ninput AftermarketDevicesFilter { owner: Address, beneficiary: Address, manufacturerId: Int }\n\ntype Connection { name: String!, address: Address!, owner: Address!, tokenId: BigInt!, tokenDID: String!, mintedAt: Time! }\n\ninput ConnectionBy { name: String, address: Address, tokenId: BigInt, tokenDID: String }\n\ntype DCN implements Node { id: ID!, node: Bytes!, tokenId: BigInt!, tokenDID: String!, owner: Address!, expiresAt: Time, mintedAt: Time!, name: String, vehicle: Vehicle }\n\ninput DCNBy @oneOf { node: Bytes, tokenDID: String, name: String }\n\ninput DCNFilter { owner: Address }\n\ntype Definition { id: String, make: String, model: String, year: Int }\n\ntype DeveloperLicense { tokenId: Int!, tokenDID: String!, owner: Address!, clientId: Address!, alias: String, mintedAt: Time!, signers(first: Int, after: String, last: Int, before: String): SignerConnection!, redirectURIs(first: Int, after: String, last: Int, before: String): RedirectURIConnection! }\n\ninput DeveloperLicenseBy { clientId: Address, alias: String, tokenId: Int, tokenDID: String }\n\ninput DeveloperLicenseFilterBy { signer: Address, owner: Address }\n\ntype DeviceDefinition { deviceDefinitionId: String!, legacyId: String, manufacturer: Manufacturer, model: String!, year: Int!, deviceType: String, imageURI: String, attributes: [DeviceDefinitionAttribute!]! }\n\ntype DeviceDefinitionAttribute { name: String!, value: String! }\n\ninput DeviceDefinitionBy @oneOf { id: String! }\n\ninput DeviceDefinitionFilter {\n \"Model filters for device definition that are of the given model. This filter performs a case insensitive match.\"\n model: String\n \"Year filters for device definition that are of the given year.\"\n year: Int\n}\n\ntype Earning { week: Int!, beneficiary: Address!, connectionStreak: Int, streakTokens: BigDecimal!, aftermarketDevice: AftermarketDevice, aftermarketDeviceTokens: BigDecimal!, syntheticDevice: SyntheticDevice, syntheticDeviceTokens: BigDecimal!, vehicle: Vehicle, sentAt: Time! }\n\ntype Manufacturer implements Node { id: ID!, tokenId: Int!, tokenDID: String!, name: String!, owner: Address!, tableId: Int, mintedAt: Time!, aftermarketDevices(first: Int, after: String, last: Int, before: String, filterBy: AftermarketDevicesFilter): AftermarketDeviceConnection!, deviceDefinitions(first: Int, after: String, last: Int, before: String, filterBy: DeviceDefinitionFilter): DeviceDefinitionConnection! }\n\ninput ManufacturerBy @oneOf { name: String, tokenId: Int, slug: String, tokenDID: String }\n\ntype MerkleEpoch { epoch: Int!, root: Bytes!, allocation: BigInt!, totalClaimed: BigInt!, claimCount: Int!, recipientCount: Int!, proofsURI: String!, setAt: Time! }\n\ntype MerklePool { poolId: Int!, token: Address!, admin: Address!, weeklyLimit: BigInt, balance: BigInt!, createdAt: Time!, epochs(first: Int, after: String, last: Int, before: String): MerkleEpochConnection! }\n\ntype MerkleReward { pool: MerklePool!, epoch: Int!, account: Address!, amount: BigInt!, proof: [String!]!, claimed: Boolean!, claimedAt: Time, claimTx: Bytes }\n\ninterface Node { id: ID! }\n\ntype PageInfo { startCursor: String, endCursor: String, hasPreviousPage: Boolean!, hasNextPage: Boolean! }\n\ntype Privilege { id: Int!, user: Address!, setAt: Time!, expiresAt: Time! }\n\ninput PrivilegeFilterBy { user: Address, privilegeId: Int }\n\ntype RedirectURI { uri: String!, enabledAt: Time! }\n\ntype Sacd { grantee: Address!, permissions: String!, source: String!, createdAt: Time!, expiresAt: Time!, template: Template }\n\ntype Signer { address: Address!, enabledAt: Time! }\n\ntype Stake { tokenId: Int!, tokenDID: String!, owner: Address!, level: Int!, points: Int!, amount: BigDecimal!, stakedAt: Time!, endsAt: Time!, withdrawnAt: Time, vehicle: Vehicle }\n\ninput StakeFilterBy {\n owner: Address\n \"Filter stakes based on attachability. A stake is considered attachable if it is not presently attached to a vehicle and has not yet ended.\"\n attachable: Boolean\n}\n\ntype StorageNode { label: String!, address: Address!, owner: Address!, tokenId: BigInt!, uri: String!, tokenDID: String!, mintedAt: Time! }\n\ntype SyntheticDevice implements Node { id: ID!, name: String!, tokenId: Int!, tokenDID: String!, address: Address!, mintedAt: Time!, vehicle: Vehicle!, connection: Connection! }\n\ninput SyntheticDeviceBy @oneOf {\n tokenId: Int\n tokenDID: String\n \"The Ethereum address for the synthetic device.\"\n address: Address\n}\n\ninput SyntheticDevicesFilter { owner: Address, integrationId: Int }\n\ntype Template { tokenId: BigInt!, creator: Address!, asset: Address!, permissions: String!, cid: String!, createdAt: Time! }\n\ninput TemplateBy { tokenId: BigInt, cid: String }\n\ntype UserRewards { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ntype Vehicle implements Node { id: ID!, tokenId: Int!, tokenDID: String!, manufacturer: Manufacturer!, owner: Address!, mintedAt: Time!, aftermarketDevice: AftermarketDevice, privileges(first: Int, after: String, last: Int, before: String, filterBy: PrivilegeFilterBy): PrivilegesConnection!, sacds(first: Int, after: String, last: Int, before: String): SacdConnection!, sacd(grantee: Address!): Sacd, syntheticDevice: SyntheticDevice, definition: Definition, dcn: DCN, name: String!, imageURI: String!, earnings: VehicleEarnings, dataURI: String!, stake: Stake, storageNode: StorageNode }\n\ntype VehicleEarnings { totalTokens: BigDecimal!, history(first: Int, after: String, last: Int, before: String): EarningsConnection! }\n\ninput VehiclesFilter {\n \"Privileged filters for vehicles to which the given address has access. This includes vehicles that this address owns.\"\n privileged: Address\n owner: Address\n \"Make filters for vehicles that are of the given make.\"\n make: String\n \"Model filters for vehicles that are of the given model.\"\n model: String\n \"Year filters for vehicles that are of the given year.\"\n year: Int\n \"Filter for vehicles produced by a particular manufacturer, specified by manufacturer token id.\"\n manufacturerTokenId: Int\n deviceDefinitionId: String\n}\n" diff --git a/graph/merkle.resolvers.go b/graph/merkle.resolvers.go new file mode 100644 index 00000000..993816b2 --- /dev/null +++ b/graph/merkle.resolvers.go @@ -0,0 +1,55 @@ +package graph + +// This file will be automatically regenerated based on the schema, any resolver +// implementations +// will be copied through when generating and any unknown code will be moved to the end. +// Code generated by github.com/99designs/gqlgen version v0.17.89 + +import ( + "context" + "fmt" + + "github.com/DIMO-Network/identity-api/graph/model" + "github.com/ethereum/go-ethereum/common" +) + +// Epochs is the resolver for the epochs field. +func (r *merklePoolResolver) Epochs(ctx context.Context, obj *model.MerklePool, first *int, after *string, last *int, before *string) (*model.MerkleEpochConnection, error) { + return r.merkle.GetPoolEpochs(ctx, obj, first, after, last, before) +} + +// Pool is the resolver for the pool field. +func (r *merkleRewardResolver) Pool(ctx context.Context, obj *model.MerkleReward) (*model.MerklePool, error) { + pool, err := r.merkle.GetMerklePool(ctx, obj.PoolID) + if err != nil { + return nil, err + } + if pool == nil { + return nil, fmt.Errorf("no pool with id %d", obj.PoolID) + } + return pool, nil +} + +// MerklePools is the resolver for the merklePools field. +func (r *queryResolver) MerklePools(ctx context.Context, first *int, after *string, last *int, before *string) (*model.MerklePoolConnection, error) { + return r.merkle.GetMerklePools(ctx, first, after, last, before) +} + +// MerklePool is the resolver for the merklePool field. +func (r *queryResolver) MerklePool(ctx context.Context, poolID int) (*model.MerklePool, error) { + return r.merkle.GetMerklePool(ctx, poolID) +} + +// MerkleRewards is the resolver for the merkleRewards field. +func (r *queryResolver) MerkleRewards(ctx context.Context, account common.Address, poolID *int, claimed *bool, first *int, after *string, last *int, before *string) (*model.MerkleRewardConnection, error) { + return r.merkle.GetMerkleRewards(ctx, account, poolID, claimed, first, after, last, before) +} + +// MerklePool returns MerklePoolResolver implementation. +func (r *Resolver) MerklePool() MerklePoolResolver { return &merklePoolResolver{r} } + +// MerkleReward returns MerkleRewardResolver implementation. +func (r *Resolver) MerkleReward() MerkleRewardResolver { return &merkleRewardResolver{r} } + +type merklePoolResolver struct{ *Resolver } +type merkleRewardResolver struct{ *Resolver } diff --git a/graph/model/models_gen.go b/graph/model/models_gen.go index 88d2c19e..6ce28fd6 100644 --- a/graph/model/models_gen.go +++ b/graph/model/models_gen.go @@ -408,6 +408,98 @@ type ManufacturerEdge struct { Cursor string `json:"cursor"` } +type MerkleEpoch struct { + // The epoch, also called the issuance week, of the root. + Epoch int `json:"epoch"` + // The Merkle root for the epoch. + Root []byte `json:"root"` + // The total amount of tokens, in wei, allocated for the epoch. + Allocation *big.Int `json:"allocation"` + // The total amount of tokens, in wei, claimed so far for the epoch. + TotalClaimed *big.Int `json:"totalClaimed"` + // The number of claims made so far for the epoch. + ClaimCount int `json:"claimCount"` + // The number of accounts with allocations in the epoch. + RecipientCount int `json:"recipientCount"` + // The URI of the Merkle tree file containing the proofs for the epoch. + ProofsURI string `json:"proofsURI"` + // The block timestamp for the transaction that set the root. + SetAt time.Time `json:"setAt"` +} + +type MerkleEpochConnection struct { + TotalCount int `json:"totalCount"` + Edges []*MerkleEpochEdge `json:"edges"` + Nodes []*MerkleEpoch `json:"nodes"` + PageInfo *PageInfo `json:"pageInfo"` +} + +type MerkleEpochEdge struct { + Node *MerkleEpoch `json:"node"` + Cursor string `json:"cursor"` +} + +type MerklePool struct { + // The id of the pool on the MerkleDistributor contract. + PoolID int `json:"poolId"` + // The address of the ERC-20 token distributed by the pool. + Token common.Address `json:"token"` + // The admin of the pool. + Admin common.Address `json:"admin"` + // The maximum amount of tokens, in wei, that can be allocated to the pool in a week. + WeeklyLimit *big.Int `json:"weeklyLimit,omitempty"` + // The current token balance of the pool, in wei. + Balance *big.Int `json:"balance"` + // The block timestamp for the transaction that created the pool. + CreatedAt time.Time `json:"createdAt"` + // The epochs for which roots have been set on this pool. Sorts by epoch, descending. + Epochs *MerkleEpochConnection `json:"epochs"` +} + +type MerklePoolConnection struct { + TotalCount int `json:"totalCount"` + Edges []*MerklePoolEdge `json:"edges"` + Nodes []*MerklePool `json:"nodes"` + PageInfo *PageInfo `json:"pageInfo"` +} + +type MerklePoolEdge struct { + Node *MerklePool `json:"node"` + Cursor string `json:"cursor"` +} + +type MerkleReward struct { + // The pool from which the reward can be claimed. + Pool *MerklePool `json:"pool"` + // The epoch, also called the issuance week, of the reward. + Epoch int `json:"epoch"` + // The account to which the reward was allocated. + Account common.Address `json:"account"` + // The amount of tokens allocated, in wei. + Amount *big.Int `json:"amount"` + // The Merkle proof for the claim, as 32-byte hex strings. + Proof []string `json:"proof"` + // Whether the reward has been claimed. + Claimed bool `json:"claimed"` + // The block timestamp for the transaction that claimed the reward, if it has been claimed. + ClaimedAt *time.Time `json:"claimedAt,omitempty"` + // The hash of the transaction that claimed the reward, if it has been claimed. + ClaimTx []byte `json:"claimTx,omitempty"` + PoolID int `json:"-"` +} + +type MerkleRewardConnection struct { + TotalCount int `json:"totalCount"` + Edges []*MerkleRewardEdge `json:"edges"` + Nodes []*MerkleReward `json:"nodes"` + PageInfo *PageInfo `json:"pageInfo"` +} + +type MerkleRewardEdge struct { + Node *MerkleReward `json:"node"` + Cursor string `json:"cursor"` +} + type PageInfo struct { StartCursor *string `json:"startCursor,omitempty"` EndCursor *string `json:"endCursor,omitempty"` diff --git a/graph/resolver.go b/graph/resolver.go index 11ac2b82..37cb8b66 100644 --- a/graph/resolver.go +++ b/graph/resolver.go @@ -13,6 +13,7 @@ import ( "github.com/DIMO-Network/identity-api/internal/repositories/developerlicense" "github.com/DIMO-Network/identity-api/internal/repositories/devicedefinition" "github.com/DIMO-Network/identity-api/internal/repositories/manufacturer" + "github.com/DIMO-Network/identity-api/internal/repositories/merkle" "github.com/DIMO-Network/identity-api/internal/repositories/reward" "github.com/DIMO-Network/identity-api/internal/repositories/stake" "github.com/DIMO-Network/identity-api/internal/repositories/synthetic" @@ -126,6 +127,7 @@ type Resolver struct { aftermarket AftermarketDeviceRepository dcn DCNRepository manufacturer ManufacturerRepository + merkle merkle.Repository reward reward.Repository synthetic SyntheticRepository vehicle VehicleRepository @@ -149,6 +151,7 @@ func NewResolver(baseRepo *base.Repository) *Resolver { aftermarket: aftermarket.New(baseRepo), dcn: dcn.New(baseRepo), manufacturer: manufacturer.New(baseRepo), + merkle: merkle.Repository{Repository: baseRepo}, reward: reward.Repository{Repository: baseRepo}, synthetic: synthetic.New(baseRepo), vehicle: vehicle.New(baseRepo), diff --git a/graph/schema/merkle.graphqls b/graph/schema/merkle.graphqls new file mode 100644 index 00000000..919e3693 --- /dev/null +++ b/graph/schema/merkle.graphqls @@ -0,0 +1,176 @@ +# MerkleDistributor reward pool types + +extend type Query { + """ + List Merkle reward pools. Sorts by pool id, descending. + """ + merklePools( + first: Int + after: String + last: Int + before: String + ): MerklePoolConnection! + """ + Look up a Merkle reward pool by its id. + """ + merklePool(poolId: Int!): MerklePool + """ + List Merkle rewards for an account, optionally filtered by pool and claim + status. Sorts by pool id and then epoch, descending. + """ + merkleRewards( + """ + The account to which the rewards were allocated. + """ + account: Address! + """ + If provided, only return rewards from this pool. + """ + poolId: Int + """ + If provided, only return rewards that have (true) or have not (false) been claimed. + """ + claimed: Boolean + first: Int + after: String + last: Int + before: String + ): MerkleRewardConnection! +} + +type MerklePool { + """ + The id of the pool on the MerkleDistributor contract. + """ + poolId: Int! + """ + The address of the ERC-20 token distributed by the pool. + """ + token: Address! + """ + The admin of the pool. + """ + admin: Address! + """ + The maximum amount of tokens, in wei, that can be allocated to the pool in a week. + """ + weeklyLimit: BigInt + """ + The current token balance of the pool, in wei. + """ + balance: BigInt! + """ + The block timestamp for the transaction that created the pool. + """ + createdAt: Time! + """ + The epochs for which roots have been set on this pool. Sorts by epoch, descending. + """ + epochs(first: Int, after: String, last: Int, before: String): MerkleEpochConnection! +} + +type MerklePoolConnection { + totalCount: Int! + edges: [MerklePoolEdge!]! + nodes: [MerklePool!]! + pageInfo: PageInfo! +} + +type MerklePoolEdge { + node: MerklePool! + cursor: String! +} + +type MerkleEpoch { + """ + The epoch, also called the issuance week, of the root. + """ + epoch: Int! + """ + The Merkle root for the epoch. + """ + root: Bytes! + """ + The total amount of tokens, in wei, allocated for the epoch. + """ + allocation: BigInt! + """ + The total amount of tokens, in wei, claimed so far for the epoch. + """ + totalClaimed: BigInt! + """ + The number of claims made so far for the epoch. + """ + claimCount: Int! + """ + The number of accounts with allocations in the epoch. + """ + recipientCount: Int! + """ + The URI of the Merkle tree file containing the proofs for the epoch. + """ + proofsURI: String! @goField(name: "ProofsURI") + """ + The block timestamp for the transaction that set the root. + """ + setAt: Time! +} + +type MerkleEpochConnection { + totalCount: Int! + edges: [MerkleEpochEdge!]! + nodes: [MerkleEpoch!]! + pageInfo: PageInfo! +} + +type MerkleEpochEdge { + node: MerkleEpoch! + cursor: String! +} + +type MerkleReward { + """ + The pool from which the reward can be claimed. + """ + pool: MerklePool! + """ + The epoch, also called the issuance week, of the reward. + """ + epoch: Int! + """ + The account to which the reward was allocated. + """ + account: Address! + """ + The amount of tokens allocated, in wei. + """ + amount: BigInt! + """ + The Merkle proof for the claim, as 32-byte hex strings. + """ + proof: [String!]! + """ + Whether the reward has been claimed. + """ + claimed: Boolean! + """ + The block timestamp for the transaction that claimed the reward, if it has been claimed. + """ + claimedAt: Time + """ + The hash of the transaction that claimed the reward, if it has been claimed. + """ + claimTx: Bytes +} + +type MerkleRewardConnection { + totalCount: Int! + edges: [MerkleRewardEdge!]! + nodes: [MerkleReward!]! + pageInfo: PageInfo! +} + +type MerkleRewardEdge { + node: MerkleReward! + cursor: String! +} diff --git a/internal/repositories/merkle/merkle.go b/internal/repositories/merkle/merkle.go new file mode 100644 index 00000000..32846f6f --- /dev/null +++ b/internal/repositories/merkle/merkle.go @@ -0,0 +1,417 @@ +// Package merkle contains the repository for MerkleDistributor pools, roots, +// and claims. +package merkle + +import ( + "context" + "database/sql" + "errors" + "fmt" + "math/big" + "slices" + + gmodel "github.com/DIMO-Network/identity-api/graph/model" + "github.com/DIMO-Network/identity-api/internal/helpers" + "github.com/DIMO-Network/identity-api/internal/repositories/base" + "github.com/DIMO-Network/identity-api/models" + "github.com/aarondl/sqlboiler/v4/queries/qm" + "github.com/aarondl/sqlboiler/v4/types" + "github.com/ethereum/go-ethereum/common" + "github.com/goccy/go-json" +) + +// Repository is the data access layer for MerkleDistributor pools, epochs, +// and rewards. +type Repository struct { + *base.Repository +} + +// RewardCursor is the pagination cursor for the merkleRewards query. +type RewardCursor struct { + PoolID int + Epoch int +} + +var rewardCursorColumns = "(" + models.MerkleClaimColumns.PoolID + ", " + models.MerkleClaimColumns.Epoch + ")" + +func decimalToBig(d types.Decimal) *big.Int { + return d.Big.Int(nil) +} + +// PoolToAPI converts a database Merkle pool row to its GraphQL form. +func PoolToAPI(pool *models.MerklePool) *gmodel.MerklePool { + out := &gmodel.MerklePool{ + PoolID: pool.PoolID, + Token: common.BytesToAddress(pool.Token), + Admin: common.BytesToAddress(pool.Admin), + Balance: decimalToBig(pool.Balance), + CreatedAt: pool.CreatedAt, + } + + if pool.WeeklyLimit.Big != nil { + out.WeeklyLimit = pool.WeeklyLimit.Big.Int(nil) + } + + return out +} + +// EpochToAPI converts a database Merkle root row to its GraphQL form. +func EpochToAPI(root *models.MerkleRoot) *gmodel.MerkleEpoch { + return &gmodel.MerkleEpoch{ + Epoch: root.Epoch, + Root: root.Root, + Allocation: decimalToBig(root.Allocation), + TotalClaimed: decimalToBig(root.TotalClaimed), + ClaimCount: root.ClaimCount, + RecipientCount: root.RecipientCount, + ProofsURI: root.ProofsURI, + SetAt: root.SetAt, + } +} + +// RewardToAPI converts a database Merkle claim row to its GraphQL form. +func RewardToAPI(claim *models.MerkleClaim) (*gmodel.MerkleReward, error) { + var proof []string + if err := json.Unmarshal(claim.Proof, &proof); err != nil { + return nil, fmt.Errorf("parsing proof for pool %d, epoch %d: %w", claim.PoolID, claim.Epoch, err) + } + if proof == nil { + proof = []string{} + } + + out := &gmodel.MerkleReward{ + PoolID: claim.PoolID, + Epoch: claim.Epoch, + Account: common.BytesToAddress(claim.Account), + Amount: decimalToBig(claim.Amount), + Proof: proof, + Claimed: claim.ClaimedAt.Valid, + ClaimedAt: claim.ClaimedAt.Ptr(), + } + + if claim.ClaimTX.Valid { + out.ClaimTx = claim.ClaimTX.Bytes + } + + return out, nil +} + +// GetMerklePool retrieves a single pool by its id. It returns nil if the pool +// does not exist. +func (r *Repository) GetMerklePool(ctx context.Context, poolID int) (*gmodel.MerklePool, error) { + pool, err := models.FindMerklePool(ctx, r.PDB.DBS().Reader, poolID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, nil + } + return nil, err + } + + return PoolToAPI(pool), nil +} + +// GetMerklePools retrieves a page of pools, sorted by pool id, descending. +func (r *Repository) GetMerklePools(ctx context.Context, first *int, after *string, last *int, before *string) (*gmodel.MerklePoolConnection, error) { + limit, err := helpers.ValidateFirstLast(first, last, base.MaxPageSize) + if err != nil { + return nil, err + } + + totalCount, err := models.MerklePools().Count(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + var queryMods []qm.QueryMod + + if after != nil { + afterID, err := helpers.CursorToID(*after) + if err != nil { + return nil, err + } + queryMods = append(queryMods, models.MerklePoolWhere.PoolID.LT(afterID)) + } + + if before != nil { + beforeID, err := helpers.CursorToID(*before) + if err != nil { + return nil, err + } + queryMods = append(queryMods, models.MerklePoolWhere.PoolID.GT(beforeID)) + } + + orderBy := "DESC" + if last != nil { + orderBy = "ASC" + } + + queryMods = append(queryMods, + qm.Limit(limit+1), + qm.OrderBy(models.MerklePoolColumns.PoolID+" "+orderBy), + ) + + all, err := models.MerklePools(queryMods...).All(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + // We assume that cursors come from real elements. + hasNext := before != nil + hasPrevious := after != nil + + if first != nil && len(all) == limit+1 { + hasNext = true + all = all[:limit] + } else if last != nil && len(all) == limit+1 { + hasPrevious = true + all = all[:limit] + } + + if last != nil { + slices.Reverse(all) + } + + edges := make([]*gmodel.MerklePoolEdge, len(all)) + nodes := make([]*gmodel.MerklePool, len(all)) + + for i, pool := range all { + node := PoolToAPI(pool) + + edges[i] = &gmodel.MerklePoolEdge{ + Node: node, + Cursor: helpers.IDToCursor(pool.PoolID), + } + nodes[i] = node + } + + var endCur, startCur *string + if len(all) != 0 { + endCur = &edges[len(edges)-1].Cursor + startCur = &edges[0].Cursor + } + + return &gmodel.MerklePoolConnection{ + TotalCount: int(totalCount), + Edges: edges, + Nodes: nodes, + PageInfo: &gmodel.PageInfo{ + StartCursor: startCur, + EndCursor: endCur, + HasPreviousPage: hasPrevious, + HasNextPage: hasNext, + }, + }, nil +} + +// GetPoolEpochs retrieves a page of epochs for a pool, sorted by epoch, +// descending. +func (r *Repository) GetPoolEpochs(ctx context.Context, obj *gmodel.MerklePool, first *int, after *string, last *int, before *string) (*gmodel.MerkleEpochConnection, error) { + limit, err := helpers.ValidateFirstLast(first, last, base.MaxPageSize) + if err != nil { + return nil, err + } + + queryMods := []qm.QueryMod{ + models.MerkleRootWhere.PoolID.EQ(obj.PoolID), + } + + totalCount, err := models.MerkleRoots(queryMods...).Count(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + if after != nil { + afterEpoch, err := helpers.CursorToID(*after) + if err != nil { + return nil, err + } + queryMods = append(queryMods, models.MerkleRootWhere.Epoch.LT(afterEpoch)) + } + + if before != nil { + beforeEpoch, err := helpers.CursorToID(*before) + if err != nil { + return nil, err + } + queryMods = append(queryMods, models.MerkleRootWhere.Epoch.GT(beforeEpoch)) + } + + orderBy := "DESC" + if last != nil { + orderBy = "ASC" + } + + queryMods = append(queryMods, + qm.Limit(limit+1), + qm.OrderBy(models.MerkleRootColumns.Epoch+" "+orderBy), + ) + + all, err := models.MerkleRoots(queryMods...).All(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + // We assume that cursors come from real elements. + hasNext := before != nil + hasPrevious := after != nil + + if first != nil && len(all) == limit+1 { + hasNext = true + all = all[:limit] + } else if last != nil && len(all) == limit+1 { + hasPrevious = true + all = all[:limit] + } + + if last != nil { + slices.Reverse(all) + } + + edges := make([]*gmodel.MerkleEpochEdge, len(all)) + nodes := make([]*gmodel.MerkleEpoch, len(all)) + + for i, root := range all { + node := EpochToAPI(root) + + edges[i] = &gmodel.MerkleEpochEdge{ + Node: node, + Cursor: helpers.IDToCursor(root.Epoch), + } + nodes[i] = node + } + + var endCur, startCur *string + if len(all) != 0 { + endCur = &edges[len(edges)-1].Cursor + startCur = &edges[0].Cursor + } + + return &gmodel.MerkleEpochConnection{ + TotalCount: int(totalCount), + Edges: edges, + Nodes: nodes, + PageInfo: &gmodel.PageInfo{ + StartCursor: startCur, + EndCursor: endCur, + HasPreviousPage: hasPrevious, + HasNextPage: hasNext, + }, + }, nil +} + +// GetMerkleRewards retrieves a page of rewards for an account, optionally +// filtered by pool and claim status. Sorts by pool id and then epoch, +// descending. +func (r *Repository) GetMerkleRewards(ctx context.Context, account common.Address, poolID *int, claimed *bool, first *int, after *string, last *int, before *string) (*gmodel.MerkleRewardConnection, error) { + limit, err := helpers.ValidateFirstLast(first, last, base.MaxPageSize) + if err != nil { + return nil, err + } + + queryMods := []qm.QueryMod{ + models.MerkleClaimWhere.Account.EQ(account.Bytes()), + } + + if poolID != nil { + queryMods = append(queryMods, models.MerkleClaimWhere.PoolID.EQ(*poolID)) + } + + if claimed != nil { + if *claimed { + queryMods = append(queryMods, models.MerkleClaimWhere.ClaimedAt.IsNotNull()) + } else { + queryMods = append(queryMods, models.MerkleClaimWhere.ClaimedAt.IsNull()) + } + } + + totalCount, err := models.MerkleClaims(queryMods...).Count(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + cursorHelper := &helpers.PaginationHelper[RewardCursor]{} + + if after != nil { + afterT, err := cursorHelper.DecodeCursor(*after) + if err != nil { + return nil, err + } + queryMods = append(queryMods, qm.Where(rewardCursorColumns+" < (?, ?)", afterT.PoolID, afterT.Epoch)) + } else if before != nil { + beforeT, err := cursorHelper.DecodeCursor(*before) + if err != nil { + return nil, err + } + queryMods = append(queryMods, qm.Where(rewardCursorColumns+" > (?, ?)", beforeT.PoolID, beforeT.Epoch)) + } + + orderBy := " DESC" + if last != nil { + orderBy = " ASC" + } + + queryMods = append(queryMods, + qm.Limit(limit+1), + qm.OrderBy(models.MerkleClaimColumns.PoolID+orderBy+", "+models.MerkleClaimColumns.Epoch+orderBy), + ) + + all, err := models.MerkleClaims(queryMods...).All(ctx, r.PDB.DBS().Reader) + if err != nil { + return nil, err + } + + // We assume that cursors come from real elements. + hasNext := before != nil + hasPrevious := after != nil + + if first != nil && len(all) == limit+1 { + hasNext = true + all = all[:limit] + } else if last != nil && len(all) == limit+1 { + hasPrevious = true + all = all[:limit] + } + + if last != nil { + slices.Reverse(all) + } + + edges := make([]*gmodel.MerkleRewardEdge, len(all)) + nodes := make([]*gmodel.MerkleReward, len(all)) + + for i, claim := range all { + node, err := RewardToAPI(claim) + if err != nil { + return nil, err + } + + cursor, err := cursorHelper.EncodeCursor(RewardCursor{PoolID: claim.PoolID, Epoch: claim.Epoch}) + if err != nil { + return nil, err + } + + edges[i] = &gmodel.MerkleRewardEdge{ + Node: node, + Cursor: cursor, + } + nodes[i] = node + } + + var endCur, startCur *string + if len(all) != 0 { + endCur = &edges[len(edges)-1].Cursor + startCur = &edges[0].Cursor + } + + return &gmodel.MerkleRewardConnection{ + TotalCount: int(totalCount), + Edges: edges, + Nodes: nodes, + PageInfo: &gmodel.PageInfo{ + StartCursor: startCur, + EndCursor: endCur, + HasPreviousPage: hasPrevious, + HasNextPage: hasNext, + }, + }, nil +} diff --git a/internal/repositories/merkle/merkle_test.go b/internal/repositories/merkle/merkle_test.go new file mode 100644 index 00000000..038e09e6 --- /dev/null +++ b/internal/repositories/merkle/merkle_test.go @@ -0,0 +1,254 @@ +package merkle + +import ( + "context" + "os" + "testing" + "time" + + "github.com/DIMO-Network/identity-api/internal/config" + "github.com/DIMO-Network/identity-api/internal/dbtypes" + "github.com/DIMO-Network/identity-api/internal/helpers" + "github.com/DIMO-Network/identity-api/internal/repositories/base" + "github.com/DIMO-Network/identity-api/models" + "github.com/aarondl/null/v8" + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/ethereum/go-ethereum/common" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "math/big" +) + +const migrationsDirRelPath = "../../../migrations" + +var ( + tokenAddr = common.HexToAddress("0xE261D618a959aFfFd53168Cd07D12E37B26761db") + adminAddr = common.HexToAddress("0xaba3A41bd932244Dd08186e4c19F1a7E48cbcDf4") + account1 = common.HexToAddress("0x2222222222222222222222222222222222222222") + account2 = common.HexToAddress("0x3333333333333333333333333333333333333333") + claimTx = common.HexToHash("0x811a85e24d0129a2018c9a6668652db63d73bc6d1c76f21b07da2162c6bfea7d") + + proof1 = []byte(`["0x1111111111111111111111111111111111111111111111111111111111111111","0x2222222222222222222222222222222222222222222222222222222222222222"]`) + proof2 = []byte(`["0x3333333333333333333333333333333333333333333333333333333333333333"]`) +) + +func setupRepo(t *testing.T) (*Repository, context.Context) { + t.Helper() + ctx := context.Background() + + logger := zerolog.New(os.Stdout).With().Timestamp().Str("app", helpers.DBSettings.Name).Logger() + pdb, _ := helpers.StartContainerDatabase(ctx, t, migrationsDirRelPath) + + repo := Repository{Repository: base.NewRepository(pdb, config.Settings{}, &logger)} + + writer := pdb.DBS().Writer + + pool := models.MerklePool{ + PoolID: 0, + Token: tokenAddr.Bytes(), + Admin: adminAddr.Bytes(), + WeeklyLimit: dbtypes.NullIntToDecimal(big.NewInt(5000)), + Balance: dbtypes.IntToDecimal(big.NewInt(900)), + CreatedAt: time.Now(), + } + require.NoError(t, pool.Insert(ctx, writer, boil.Infer())) + + root213 := models.MerkleRoot{ + PoolID: 0, + Epoch: 213, + Root: common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Bytes(), + Allocation: dbtypes.IntToDecimal(big.NewInt(300)), + TotalClaimed: dbtypes.IntToDecimal(big.NewInt(100)), + ClaimCount: 1, + RecipientCount: 2, + ProofsURI: "https://merkle.dimo.zone/pool-0/week-213.json", + SetAt: time.Now(), + } + require.NoError(t, root213.Insert(ctx, writer, boil.Infer())) + + root214 := models.MerkleRoot{ + PoolID: 0, + Epoch: 214, + Root: common.HexToHash("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb").Bytes(), + Allocation: dbtypes.IntToDecimal(big.NewInt(400)), + TotalClaimed: dbtypes.IntToDecimal(big.NewInt(0)), + ClaimCount: 0, + RecipientCount: 1, + ProofsURI: "https://merkle.dimo.zone/pool-0/week-214.json", + SetAt: time.Now(), + } + require.NoError(t, root214.Insert(ctx, writer, boil.Infer())) + + claimed := models.MerkleClaim{ + PoolID: 0, + Epoch: 213, + Account: account1.Bytes(), + Amount: dbtypes.IntToDecimal(big.NewInt(100)), + Proof: proof1, + ClaimedAt: null.TimeFrom(time.Now()), + ClaimTX: null.BytesFrom(claimTx.Bytes()), + } + require.NoError(t, claimed.Insert(ctx, writer, boil.Infer())) + + unclaimed := models.MerkleClaim{ + PoolID: 0, + Epoch: 214, + Account: account1.Bytes(), + Amount: dbtypes.IntToDecimal(big.NewInt(150)), + Proof: proof2, + } + require.NoError(t, unclaimed.Insert(ctx, writer, boil.Infer())) + + other := models.MerkleClaim{ + PoolID: 0, + Epoch: 213, + Account: account2.Bytes(), + Amount: dbtypes.IntToDecimal(big.NewInt(200)), + Proof: proof1, + } + require.NoError(t, other.Insert(ctx, writer, boil.Infer())) + + return &repo, ctx +} + +func TestGetMerklePool(t *testing.T) { + repo, ctx := setupRepo(t) + + pool, err := repo.GetMerklePool(ctx, 0) + require.NoError(t, err) + require.NotNil(t, pool) + assert.Equal(t, 0, pool.PoolID) + assert.Equal(t, tokenAddr, pool.Token) + assert.Equal(t, adminAddr, pool.Admin) + assert.Equal(t, "5000", pool.WeeklyLimit.String()) + assert.Equal(t, "900", pool.Balance.String()) + + missing, err := repo.GetMerklePool(ctx, 7) + require.NoError(t, err) + assert.Nil(t, missing) +} + +func TestGetMerklePools(t *testing.T) { + repo, ctx := setupRepo(t) + + first := 10 + conn, err := repo.GetMerklePools(ctx, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 1, conn.TotalCount) + require.Len(t, conn.Nodes, 1) + assert.Equal(t, 0, conn.Nodes[0].PoolID) + assert.False(t, conn.PageInfo.HasNextPage) +} + +func TestGetPoolEpochs(t *testing.T) { + repo, ctx := setupRepo(t) + + pool, err := repo.GetMerklePool(ctx, 0) + require.NoError(t, err) + + first := 10 + conn, err := repo.GetPoolEpochs(ctx, pool, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 2, conn.TotalCount) + require.Len(t, conn.Nodes, 2) + + // Descending by epoch. + assert.Equal(t, 214, conn.Nodes[0].Epoch) + assert.Equal(t, 213, conn.Nodes[1].Epoch) + + assert.Equal(t, "400", conn.Nodes[0].Allocation.String()) + assert.Equal(t, 1, conn.Nodes[0].RecipientCount) + assert.Equal(t, "100", conn.Nodes[1].TotalClaimed.String()) + assert.Equal(t, 1, conn.Nodes[1].ClaimCount) + assert.Equal(t, "https://merkle.dimo.zone/pool-0/week-213.json", conn.Nodes[1].ProofsURI) + + // Pagination with first = 1. + one := 1 + page, err := repo.GetPoolEpochs(ctx, pool, &one, nil, nil, nil) + require.NoError(t, err) + require.Len(t, page.Nodes, 1) + assert.Equal(t, 214, page.Nodes[0].Epoch) + assert.True(t, page.PageInfo.HasNextPage) + + next, err := repo.GetPoolEpochs(ctx, pool, &one, page.PageInfo.EndCursor, nil, nil) + require.NoError(t, err) + require.Len(t, next.Nodes, 1) + assert.Equal(t, 213, next.Nodes[0].Epoch) +} + +func TestGetMerkleRewards(t *testing.T) { + repo, ctx := setupRepo(t) + + first := 10 + + conn, err := repo.GetMerkleRewards(ctx, account1, nil, nil, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 2, conn.TotalCount) + require.Len(t, conn.Nodes, 2) + + // Descending by (pool, epoch). + unclaimed, claimed := conn.Nodes[0], conn.Nodes[1] + + assert.Equal(t, 214, unclaimed.Epoch) + assert.Equal(t, account1, unclaimed.Account) + assert.Equal(t, "150", unclaimed.Amount.String()) + assert.False(t, unclaimed.Claimed) + assert.Nil(t, unclaimed.ClaimedAt) + assert.Nil(t, unclaimed.ClaimTx) + assert.Equal(t, []string{"0x3333333333333333333333333333333333333333333333333333333333333333"}, unclaimed.Proof) + + assert.Equal(t, 213, claimed.Epoch) + assert.Equal(t, "100", claimed.Amount.String()) + assert.True(t, claimed.Claimed) + require.NotNil(t, claimed.ClaimedAt) + assert.Equal(t, claimTx.Bytes(), claimed.ClaimTx) + assert.Len(t, claimed.Proof, 2) + + // Filter on claim status. + claimedTrue := true + conn, err = repo.GetMerkleRewards(ctx, account1, nil, &claimedTrue, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 1, conn.TotalCount) + require.Len(t, conn.Nodes, 1) + assert.Equal(t, 213, conn.Nodes[0].Epoch) + + claimedFalse := false + conn, err = repo.GetMerkleRewards(ctx, account1, nil, &claimedFalse, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 1, conn.TotalCount) + require.Len(t, conn.Nodes, 1) + assert.Equal(t, 214, conn.Nodes[0].Epoch) + + // Filter on pool. + poolID := 0 + conn, err = repo.GetMerkleRewards(ctx, account1, &poolID, nil, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 2, conn.TotalCount) + + otherPool := 5 + conn, err = repo.GetMerkleRewards(ctx, account1, &otherPool, nil, &first, nil, nil, nil) + require.NoError(t, err) + assert.Zero(t, conn.TotalCount) + assert.Empty(t, conn.Nodes) + + // Other account only sees its own rewards. + conn, err = repo.GetMerkleRewards(ctx, account2, nil, nil, &first, nil, nil, nil) + require.NoError(t, err) + assert.Equal(t, 1, conn.TotalCount) + require.Len(t, conn.Nodes, 1) + assert.Equal(t, "200", conn.Nodes[0].Amount.String()) + + // Cursor pagination. + one := 1 + page, err := repo.GetMerkleRewards(ctx, account1, nil, nil, &one, nil, nil, nil) + require.NoError(t, err) + require.Len(t, page.Nodes, 1) + assert.Equal(t, 214, page.Nodes[0].Epoch) + assert.True(t, page.PageInfo.HasNextPage) + + next, err := repo.GetMerkleRewards(ctx, account1, nil, nil, &one, page.PageInfo.EndCursor, nil, nil) + require.NoError(t, err) + require.Len(t, next.Nodes, 1) + assert.Equal(t, 213, next.Nodes[0].Epoch) +} From 4ed4125af558661b41d0ef514c3a2fb8f1d0cb7d Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 09:52:40 -0400 Subject: [PATCH 06/11] test(consumer): cover Merkle tree HTTP fetcher limits --- internal/services/merkle/fetcher_test.go | 68 ++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 internal/services/merkle/fetcher_test.go diff --git a/internal/services/merkle/fetcher_test.go b/internal/services/merkle/fetcher_test.go new file mode 100644 index 00000000..2ba24606 --- /dev/null +++ b/internal/services/merkle/fetcher_test.go @@ -0,0 +1,68 @@ +package merkle + +import ( + "bytes" + "context" + "net/http" + "net/http/httptest" + "net/url" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestHTTPTreeFetcherHostAllowlist(t *testing.T) { + ctx := context.Background() + + srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte("tree file")) + })) + defer srv.Close() + + srvURL, err := url.Parse(srv.URL) + require.NoError(t, err) + + f := NewHTTPTreeFetcher(srv.Client(), " merkle.dimo.zone, "+srvURL.Host) + assert.Equal(t, []string{"merkle.dimo.zone", srvURL.Host}, f.AllowedHosts) + + // Allowed host works. + body, err := f.Fetch(ctx, srv.URL+"/pool-0/week-214.json") + require.NoError(t, err) + assert.Equal(t, []byte("tree file"), body) + + // Hosts not in the list are rejected. + _, err = f.Fetch(ctx, "https://evil.example.com/pool-0/week-214.json") + assert.ErrorContains(t, err, "not in the allowed list") + + // Non-HTTPS schemes are rejected. + _, err = f.Fetch(ctx, "http://"+srvURL.Host+"/pool-0/week-214.json") + assert.ErrorContains(t, err, "does not use https") +} + +func TestHTTPTreeFetcherStatusAndSizeLimits(t *testing.T) { + ctx := context.Background() + + big := bytes.Repeat([]byte{0}, maxTreeFileSize+1) + + srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case "/missing.json": + w.WriteHeader(http.StatusNotFound) + case "/big.json": + _, _ = w.Write(big) + } + })) + defer srv.Close() + + srvURL, err := url.Parse(srv.URL) + require.NoError(t, err) + + f := NewHTTPTreeFetcher(srv.Client(), srvURL.Host) + + _, err = f.Fetch(ctx, srv.URL+"/missing.json") + assert.ErrorContains(t, err, "status code 404") + + _, err = f.Fetch(ctx, srv.URL+"/big.json") + assert.ErrorContains(t, err, "exceeds the size limit") +} From 4eb3658dd899c6cd9c232f6813bdab4e32b89551 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 10:13:33 -0400 Subject: [PATCH 07/11] fix(merkle): harden tree fetcher and event handling - Guard the HTTP tree fetcher against SSRF via redirects by re-validating every redirect target against the HTTPS scheme and host allowlist - Apply both after and before cursors in GetMerkleRewards instead of dropping before when after is set - Reject MerkleDistributor event poolId/week arguments that overflow int64 - Put the MERKLE_DISTRIBUTOR_ADDR TODO comment on its own line in settings.sample.yaml --- internal/repositories/merkle/merkle.go | 4 +- internal/repositories/merkle/merkle_test.go | 6 ++ internal/services/merkle/fetcher.go | 38 ++++++++++--- internal/services/merkle/fetcher_test.go | 23 ++++++++ internal/services/merkle/handler.go | 61 ++++++++++++++++++--- internal/services/merkle/handler_test.go | 25 +++++++++ settings.sample.yaml | 3 +- 7 files changed, 143 insertions(+), 17 deletions(-) diff --git a/internal/repositories/merkle/merkle.go b/internal/repositories/merkle/merkle.go index 32846f6f..18e369fd 100644 --- a/internal/repositories/merkle/merkle.go +++ b/internal/repositories/merkle/merkle.go @@ -337,7 +337,9 @@ func (r *Repository) GetMerkleRewards(ctx context.Context, account common.Addres return nil, err } queryMods = append(queryMods, qm.Where(rewardCursorColumns+" < (?, ?)", afterT.PoolID, afterT.Epoch)) - } else if before != nil { + } + + if before != nil { beforeT, err := cursorHelper.DecodeCursor(*before) if err != nil { return nil, err diff --git a/internal/repositories/merkle/merkle_test.go b/internal/repositories/merkle/merkle_test.go index 038e09e6..7b072766 100644 --- a/internal/repositories/merkle/merkle_test.go +++ b/internal/repositories/merkle/merkle_test.go @@ -251,4 +251,10 @@ func TestGetMerkleRewards(t *testing.T) { require.NoError(t, err) require.Len(t, next.Nodes, 1) assert.Equal(t, 213, next.Nodes[0].Epoch) + + // Both cursors set: only elements strictly between them. The window + // between epoch 214 and epoch 213 is empty. + both, err := repo.GetMerkleRewards(ctx, account1, nil, nil, &first, page.PageInfo.EndCursor, nil, next.PageInfo.EndCursor) + require.NoError(t, err) + assert.Empty(t, both.Nodes) } diff --git a/internal/services/merkle/fetcher.go b/internal/services/merkle/fetcher.go index 6f3036b7..ed4f39d2 100644 --- a/internal/services/merkle/fetcher.go +++ b/internal/services/merkle/fetcher.go @@ -2,6 +2,7 @@ package merkle import ( "context" + "errors" "fmt" "io" "net/http" @@ -28,7 +29,9 @@ type HTTPTreeFetcher struct { } // NewHTTPTreeFetcher creates an HTTPTreeFetcher from a comma-separated list of -// allowed hosts. +// allowed hosts. The given client is copied and fitted with a redirect check +// that re-validates every redirect target against the allowlist, so redirects +// cannot be used to escape it. func NewHTTPTreeFetcher(client *http.Client, allowedHosts string) *HTTPTreeFetcher { var hosts []string for h := range strings.SplitSeq(allowedHosts, ",") { @@ -36,7 +39,31 @@ func NewHTTPTreeFetcher(client *http.Client, allowedHosts string) *HTTPTreeFetch hosts = append(hosts, strings.ToLower(h)) } } - return &HTTPTreeFetcher{Client: client, AllowedHosts: hosts} + + f := &HTTPTreeFetcher{AllowedHosts: hosts} + + guarded := *client + guarded.CheckRedirect = func(req *http.Request, via []*http.Request) error { + if len(via) >= 10 { + return errors.New("stopped after 10 redirects") + } + return f.validateURL(req.URL) + } + f.Client = &guarded + + return f +} + +// validateURL checks that the URL uses HTTPS and that its host is in the +// allowlist. +func (f *HTTPTreeFetcher) validateURL(u *url.URL) error { + if u.Scheme != "https" { + return fmt.Errorf("URL %q does not use https", u.Redacted()) + } + if !slices.Contains(f.AllowedHosts, strings.ToLower(u.Host)) { + return fmt.Errorf("host %q is not in the allowed list", u.Host) + } + return nil } // Fetch retrieves the file at the given URI, enforcing the host allowlist and @@ -46,11 +73,8 @@ func (f *HTTPTreeFetcher) Fetch(ctx context.Context, uri string) ([]byte, error) if err != nil { return nil, fmt.Errorf("parsing proofs URI %q: %w", uri, err) } - if u.Scheme != "https" { - return nil, fmt.Errorf("proofs URI %q does not use https", uri) - } - if !slices.Contains(f.AllowedHosts, strings.ToLower(u.Host)) { - return nil, fmt.Errorf("proofs URI host %q is not in the allowed list", u.Host) + if err := f.validateURL(u); err != nil { + return nil, fmt.Errorf("proofs URI %q: %w", uri, err) } req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil) diff --git a/internal/services/merkle/fetcher_test.go b/internal/services/merkle/fetcher_test.go index 2ba24606..a131084a 100644 --- a/internal/services/merkle/fetcher_test.go +++ b/internal/services/merkle/fetcher_test.go @@ -40,6 +40,29 @@ func TestHTTPTreeFetcherHostAllowlist(t *testing.T) { assert.ErrorContains(t, err, "does not use https") } +func TestHTTPTreeFetcherRefusesRedirectToDisallowedHost(t *testing.T) { + ctx := context.Background() + + srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + http.Redirect(w, r, "https://evil.example.com/pool-0/week-214.json", http.StatusFound) + })) + defer srv.Close() + + srvURL, err := url.Parse(srv.URL) + require.NoError(t, err) + + client := srv.Client() + f := NewHTTPTreeFetcher(client, srvURL.Host) + + // The original client must not be mutated. + assert.Nil(t, client.CheckRedirect) + + // The initial host is allowed, but the redirect target is not. + _, err = f.Fetch(ctx, srv.URL+"/pool-0/week-214.json") + require.Error(t, err) + assert.ErrorContains(t, err, "not in the allowed list") +} + func TestHTTPTreeFetcherStatusAndSizeLimits(t *testing.T) { ctx := context.Background() diff --git a/internal/services/merkle/handler.go b/internal/services/merkle/handler.go index cc8b682f..0f44346f 100644 --- a/internal/services/merkle/handler.go +++ b/internal/services/merkle/handler.go @@ -7,6 +7,7 @@ import ( "database/sql" "errors" "fmt" + "math/big" "github.com/DIMO-Network/identity-api/internal/dbtypes" "github.com/DIMO-Network/identity-api/internal/helpers" @@ -29,6 +30,15 @@ type Handler struct { Fetcher TreeFetcher } +// toInt converts a big.Int event argument to an int, returning an error if +// the value does not fit in an int64. +func toInt(name string, x *big.Int) (int, error) { + if !x.IsInt64() { + return 0, fmt.Errorf("event argument %s value %s does not fit in an int64", name, x) + } + return int(x.Int64()), nil +} + // Handle routes a MerkleDistributor contract event to the matching handler. func (h *Handler) Handle(ctx context.Context, event *cmodels.ContractEventData) error { switch event.EventName { @@ -74,8 +84,13 @@ func (h *Handler) Handle(ctx context.Context, event *cmodels.ContractEventData) } func (h *Handler) handlePoolCreated(ctx context.Context, e *cmodels.ContractEventData, args *PoolCreatedData) error { + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + pool := models.MerklePool{ - PoolID: int(args.PoolId.Int64()), + PoolID: poolID, Token: args.Token.Bytes(), Admin: args.Admin.Bytes(), WeeklyLimit: dbtypes.NullIntToDecimal(args.WeeklyLimit), @@ -93,8 +108,13 @@ func (h *Handler) handlePoolCreated(ctx context.Context, e *cmodels.ContractEven } func (h *Handler) handleWeeklyLimitSet(ctx context.Context, e *cmodels.ContractEventData, args *WeeklyLimitSetData) error { + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + pool := models.MerklePool{ - PoolID: int(args.PoolId.Int64()), + PoolID: poolID, WeeklyLimit: dbtypes.NullIntToDecimal(args.Limit), } @@ -110,9 +130,14 @@ func (h *Handler) handleWeeklyLimitSet(ctx context.Context, e *cmodels.ContractE } func (h *Handler) handleFunded(ctx context.Context, e *cmodels.ContractEventData, args *FundedData) error { + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + res, err := h.DBS.DBS().Writer.ExecContext(ctx, fmt.Sprintf("UPDATE %s SET balance = balance + $1 WHERE pool_id = $2", helpers.WithSchema(models.TableNames.MerklePools)), - dbtypes.IntToDecimal(args.Amount), int(args.PoolId.Int64()), + dbtypes.IntToDecimal(args.Amount), poolID, ) if err != nil { return err @@ -129,8 +154,13 @@ func (h *Handler) handleFunded(ctx context.Context, e *cmodels.ContractEventData } func (h *Handler) handleSwept(ctx context.Context, e *cmodels.ContractEventData, args *SweptData) error { + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + pool := models.MerklePool{ - PoolID: int(args.PoolId.Int64()), + PoolID: poolID, Balance: dbtypes.IntToDecimal(args.NewBalance), } @@ -146,6 +176,15 @@ func (h *Handler) handleSwept(ctx context.Context, e *cmodels.ContractEventData, } func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventData, args *RootSetData) error { + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + epoch, err := toInt("week", args.Week) + if err != nil { + return err + } + logger := h.Logger.With(). Str("EventName", RootSet). Str("poolId", args.PoolId.String()). @@ -192,8 +231,8 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat defer tx.Rollback() //nolint:errcheck root := models.MerkleRoot{ - PoolID: int(args.PoolId.Int64()), - Epoch: int(args.Week.Int64()), + PoolID: poolID, + Epoch: epoch, Root: args.Root[:], Allocation: dbtypes.IntToDecimal(args.Allocation), RecipientCount: len(file.Leaves), @@ -254,8 +293,14 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat } func (h *Handler) handleClaimed(ctx context.Context, e *cmodels.ContractEventData, args *ClaimedData) error { - poolID := int(args.PoolId.Int64()) - epoch := int(args.Week.Int64()) + poolID, err := toInt("poolId", args.PoolId) + if err != nil { + return err + } + epoch, err := toInt("week", args.Week) + if err != nil { + return err + } tx, err := h.DBS.DBS().Writer.BeginTx(ctx, nil) if err != nil { diff --git a/internal/services/merkle/handler_test.go b/internal/services/merkle/handler_test.go index 4ab2bdb6..656b83cb 100644 --- a/internal/services/merkle/handler_test.go +++ b/internal/services/merkle/handler_test.go @@ -156,6 +156,31 @@ func TestHandlePoolCreatedAndBalanceEvents(t *testing.T) { assert.Error(t, err) } +func TestHandleOverflowingArgumentsError(t *testing.T) { + ctx := context.Background() + + // 2^64 does not fit in an int64. The guards run before any database + // access, so a bare handler suffices. + huge := new(big.Int).Lsh(big.NewInt(1), 64) + h := &Handler{} + + err := h.Handle(ctx, eventData(t, PoolCreated, time.Now(), PoolCreatedData{ + PoolId: huge, + Token: tokenAddr, + Admin: adminAddr, + WeeklyLimit: big.NewInt(5000), + })) + assert.ErrorContains(t, err, "does not fit in an int64") + + err = h.Handle(ctx, eventData(t, Claimed, time.Now(), ClaimedData{ + PoolId: big.NewInt(0), + Week: huge, + Account: account1, + Amount: big.NewInt(100), + })) + assert.ErrorContains(t, err, "does not fit in an int64") +} + func TestHandleRootSet(t *testing.T) { tree, treeData := buildTree(t, 0, 214) uri := "https://merkle.dimo.zone/pool-0/week-214.json" diff --git a/settings.sample.yaml b/settings.sample.yaml index c2537065..6acb0d77 100644 --- a/settings.sample.yaml +++ b/settings.sample.yaml @@ -19,7 +19,8 @@ REWARDS_CONTRACT_ADDRESS: "0x375885164266d48C48abbbb439Be98864Ae62bBE" TEMPLATE_ADDR: "0x0000000000000000000000000000000000000000" BASE_IMAGE_URL: "https://devices-api.dev.dimo.zone/v1/" TABLELAND_API_GATEWAY: "https://testnets.tableland.network/" -ETHEREUM_RPC_URL: "http://127.0.0.1:8545"# TODO: replace placeholder with deployed MerkleDistributor address. +ETHEREUM_RPC_URL: "http://127.0.0.1:8545" +# TODO: replace placeholder with deployed MerkleDistributor address. MERKLE_DISTRIBUTOR_ADDR: "0x0000000000000000000000000000000000000000" # Comma-separated list of hosts from which RootSet Merkle tree files may be fetched, e.g. merkle.dimo.zone. MERKLE_TREE_ALLOWED_HOST: "" From 1a3e25ea2949c35b131ccb7676a070a8114a342d Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 14:16:07 -0400 Subject: [PATCH 08/11] perf(merkle): batch claim upserts, tune indexes, add pool dataloader Review fixes for the Merkle claims indexing feature: - Replace the per-leaf claim Upsert loop in handleRootSet with a single INSERT ... SELECT unnest(...) ON CONFLICT statement; claimed_at and claim_tx are still preserved on conflict since they are not in the SET list. Covered by a new 150-leaf handler test that also exercises redelivery through the conflict path. - Replace the single-column merkle_claims account index with a composite (account, pool_id, epoch DESC) index matching the merkleRewards query and cursor order, and add a partial index on account WHERE claimed_at IS NULL for the unclaimed-by-account hot path. Indexes do not affect SQLBoiler models, so no regen needed. - Resolve MerkleReward.pool through a new MerklePoolByID dataloader instead of one query per reward row. - Log fetchDurationMs and dbWriteDurationMs when a root is set, and document why the tree-file/event root mismatch path intentionally returns an error (Kafka redelivery is the operator alert). - Hoist the tree fetcher's 10s timeout into merkle.FetchTimeout with a comment noting it spans the full body read of up to 50 MiB. - Document and pin the RootSet root wire format: even as an indexed parameter, bytes32 decodes via abi.ParseTopicsIntoMap/toGoType to a [32]byte and serializes as a JSON number array (verified against go-ethereum v1.15.11, contract-event-processor's version), so the Root field stays [32]byte and the consumer needs no wire change. --- graph/merkle.resolvers.go | 3 +- internal/loader/loader.go | 7 ++ internal/loader/merkle_pool_loader.go | 59 ++++++++++++ internal/loader/merkle_pool_loader_test.go | 75 +++++++++++++++ .../services/contracts_events_consumer.go | 2 +- internal/services/merkle/events.go | 10 +- internal/services/merkle/fetcher.go | 9 ++ internal/services/merkle/handler.go | 66 +++++++++----- internal/services/merkle/handler_test.go | 91 +++++++++++++++++++ migrations/00049_create_merkle_tables.sql | 8 +- 10 files changed, 304 insertions(+), 26 deletions(-) create mode 100644 internal/loader/merkle_pool_loader.go create mode 100644 internal/loader/merkle_pool_loader_test.go diff --git a/graph/merkle.resolvers.go b/graph/merkle.resolvers.go index 993816b2..d758b1b6 100644 --- a/graph/merkle.resolvers.go +++ b/graph/merkle.resolvers.go @@ -10,6 +10,7 @@ import ( "fmt" "github.com/DIMO-Network/identity-api/graph/model" + "github.com/DIMO-Network/identity-api/internal/loader" "github.com/ethereum/go-ethereum/common" ) @@ -20,7 +21,7 @@ func (r *merklePoolResolver) Epochs(ctx context.Context, obj *model.MerklePool, // Pool is the resolver for the pool field. func (r *merkleRewardResolver) Pool(ctx context.Context, obj *model.MerkleReward) (*model.MerklePool, error) { - pool, err := r.merkle.GetMerklePool(ctx, obj.PoolID) + pool, err := loader.GetMerklePoolByID(ctx, obj.PoolID) if err != nil { return nil, err } diff --git a/internal/loader/loader.go b/internal/loader/loader.go index 60ebf536..72993af3 100644 --- a/internal/loader/loader.go +++ b/internal/loader/loader.go @@ -11,6 +11,7 @@ import ( "github.com/DIMO-Network/identity-api/internal/repositories/connection" "github.com/DIMO-Network/identity-api/internal/repositories/dcn" "github.com/DIMO-Network/identity-api/internal/repositories/manufacturer" + "github.com/DIMO-Network/identity-api/internal/repositories/merkle" "github.com/DIMO-Network/identity-api/internal/repositories/stake" "github.com/DIMO-Network/identity-api/internal/repositories/storagenode" "github.com/DIMO-Network/identity-api/internal/repositories/synthetic" @@ -38,6 +39,7 @@ type Loaders struct { StakeByVehicleID dataloader.Interface[int, *model.Stake] ConnectionByID dataloader.Interface[ConnectionQueryKey, *model.Connection] StorageNodeByID dataloader.Interface[[32]byte, *model.StorageNode] + MerklePoolByID dataloader.Interface[int, *model.MerklePool] } // NewDataLoader returns the instantiated Loaders struct for use in a request @@ -57,6 +59,7 @@ func NewDataLoaderWithFetcher(dbs db.Store, settings config.Settings, log *zerol stake := NewStakeLoader(stake.New(baseRepo)) connection := ConnectionLoader{repo: connection.New(baseRepo)} storageNode := NewStorageNodeLoader(storagenode.New(baseRepo)) + merklePool := NewMerklePoolLoader(&merkle.Repository{Repository: baseRepo}) // return the DataLoader return &Loaders{ @@ -100,6 +103,10 @@ func NewDataLoaderWithFetcher(dbs db.Store, settings config.Settings, log *zerol storageNode.BatchGetStorageNodesByIDs, dataloader.WithClearCacheOnBatch[[32]byte, *model.StorageNode](), ), + MerklePoolByID: dataloader.NewBatchedLoader( + merklePool.BatchGetMerklePoolsByID, + dataloader.WithClearCacheOnBatch[int, *model.MerklePool](), + ), } } diff --git a/internal/loader/merkle_pool_loader.go b/internal/loader/merkle_pool_loader.go new file mode 100644 index 00000000..7335a976 --- /dev/null +++ b/internal/loader/merkle_pool_loader.go @@ -0,0 +1,59 @@ +package loader + +import ( + "context" + + "github.com/DIMO-Network/identity-api/graph/model" + "github.com/DIMO-Network/identity-api/internal/repositories/merkle" + "github.com/DIMO-Network/identity-api/models" + "github.com/graph-gophers/dataloader/v7" +) + +// MerklePoolLoader batches lookups of Merkle pools by pool id, so resolving +// the pool field on a page of rewards costs one query instead of one per row. +type MerklePoolLoader struct { + repo *merkle.Repository +} + +func NewMerklePoolLoader(repo *merkle.Repository) *MerklePoolLoader { + return &MerklePoolLoader{repo: repo} +} + +// GetMerklePoolByID enqueues a pool lookup on the request's dataloader and +// returns the result. It returns nil without error if the pool does not +// exist. +func GetMerklePoolByID(ctx context.Context, poolID int) (*model.MerklePool, error) { + // read loader from context + loaders := ctx.Value(dataLoadersKey).(*Loaders) + // invoke and get thunk + thunk := loaders.MerklePoolByID.Load(ctx, poolID) + // read value from thunk + return thunk() +} + +func (m *MerklePoolLoader) BatchGetMerklePoolsByID(ctx context.Context, poolIDs []int) []*dataloader.Result[*model.MerklePool] { + results := make([]*dataloader.Result[*model.MerklePool], len(poolIDs)) + + pools, err := models.MerklePools(models.MerklePoolWhere.PoolID.IN(poolIDs)).All(ctx, m.repo.PDB.DBS().Reader) + if err != nil { + for i := range poolIDs { + results[i] = &dataloader.Result[*model.MerklePool]{Error: err} + } + return results + } + + poolByID := make(map[int]*model.MerklePool, len(pools)) + for _, p := range pools { + poolByID[p.PoolID] = merkle.PoolToAPI(p) + } + + for i, id := range poolIDs { + if pool, ok := poolByID[id]; ok { + results[i] = &dataloader.Result[*model.MerklePool]{Data: pool} + } else { + results[i] = &dataloader.Result[*model.MerklePool]{} + } + } + + return results +} diff --git a/internal/loader/merkle_pool_loader_test.go b/internal/loader/merkle_pool_loader_test.go new file mode 100644 index 00000000..bab013da --- /dev/null +++ b/internal/loader/merkle_pool_loader_test.go @@ -0,0 +1,75 @@ +package loader + +import ( + "context" + "math/big" + "testing" + "time" + + "github.com/DIMO-Network/identity-api/internal/config" + "github.com/DIMO-Network/identity-api/internal/dbtypes" + "github.com/DIMO-Network/identity-api/internal/helpers" + "github.com/DIMO-Network/identity-api/internal/repositories/base" + "github.com/DIMO-Network/identity-api/internal/repositories/merkle" + "github.com/DIMO-Network/identity-api/models" + "github.com/aarondl/sqlboiler/v4/boil" + "github.com/ethereum/go-ethereum/common" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestBatchGetMerklePoolsByID(t *testing.T) { + ctx := context.Background() + + pdb, cont := helpers.StartContainerDatabase(ctx, t, migrationsDir) + + defer cont.Terminate(t.Context()) //nolint + + log := zerolog.Nop() + + ml := NewMerklePoolLoader(&merkle.Repository{Repository: base.NewRepository(pdb, config.Settings{}, &log)}) + + tokenAddr := common.HexToAddress("0xE261D618a959aFfFd53168Cd07D12E37B26761db") + adminAddr := common.HexToAddress("0xaba3A41bd932244Dd08186e4c19F1a7E48cbcDf4") + + for _, poolID := range []int{0, 1} { + pool := models.MerklePool{ + PoolID: poolID, + Token: tokenAddr.Bytes(), + Admin: adminAddr.Bytes(), + Balance: dbtypes.IntToDecimal(big.NewInt(int64(1000 * (poolID + 1)))), + CreatedAt: time.Now(), + } + require.NoError(t, pool.Insert(t.Context(), pdb.DBS().Writer, boil.Infer())) + } + + results := ml.BatchGetMerklePoolsByID(t.Context(), []int{1, 0, 1, 99}) + + require.Len(t, results, 4) + + if assert.NoError(t, results[0].Error) { + require.NotNil(t, results[0].Data) + assert.Equal(t, 1, results[0].Data.PoolID) + assert.Equal(t, tokenAddr, results[0].Data.Token) + assert.Equal(t, adminAddr, results[0].Data.Admin) + assert.Equal(t, "2000", results[0].Data.Balance.String()) + } + + if assert.NoError(t, results[1].Error) { + require.NotNil(t, results[1].Data) + assert.Equal(t, 0, results[1].Data.PoolID) + assert.Equal(t, "1000", results[1].Data.Balance.String()) + } + + // Duplicate keys in the batch each get the same pool. + if assert.NoError(t, results[2].Error) { + require.NotNil(t, results[2].Data) + assert.Equal(t, 1, results[2].Data.PoolID) + } + + // Unknown pools resolve to nil without error. + if assert.NoError(t, results[3].Error) { + assert.Nil(t, results[3].Data) + } +} diff --git a/internal/services/contracts_events_consumer.go b/internal/services/contracts_events_consumer.go index 10e01719..d68ba5da 100644 --- a/internal/services/contracts_events_consumer.go +++ b/internal/services/contracts_events_consumer.go @@ -107,7 +107,7 @@ const contractEventCEType = "zone.dimo.contract.event" func NewContractsEventsConsumer(dbs db.Store, log *zerolog.Logger, settings *config.Settings) *ContractsEventsConsumer { httpClient := &http.Client{ - Timeout: 10 * time.Second, + Timeout: merkle.FetchTimeout, } return &ContractsEventsConsumer{ diff --git a/internal/services/merkle/events.go b/internal/services/merkle/events.go index b175448d..bcf70610 100644 --- a/internal/services/merkle/events.go +++ b/internal/services/merkle/events.go @@ -24,7 +24,15 @@ type PoolCreatedData struct { WeeklyLimit *big.Int `json:"weeklyLimit"` } -// RootSetData represents RootSet(uint256 indexed poolId, uint256 indexed week, bytes32 root, uint256 allocation, string proofsURI). +// RootSetData represents RootSet(uint256 indexed poolId, uint256 indexed week, bytes32 indexed root, uint256 allocation, string proofsURI). +// +// Note that root being indexed does not change its wire format: +// contract-event-processor decodes indexed parameters with +// abi.ParseTopicsIntoMap, and for a fixed-size bytes32 that falls through to +// abi.toGoType, which yields a [32]byte — the same Go type UnpackIntoMap +// produces for a non-indexed bytes32. Either way root arrives in the event +// arguments JSON as an array of numbers, not a hex string. (Verified against +// go-ethereum v1.15.11, the version contract-event-processor builds with.) type RootSetData struct { PoolId *big.Int `json:"poolId"` Week *big.Int `json:"week"` diff --git a/internal/services/merkle/fetcher.go b/internal/services/merkle/fetcher.go index ed4f39d2..e21ba63d 100644 --- a/internal/services/merkle/fetcher.go +++ b/internal/services/merkle/fetcher.go @@ -9,12 +9,21 @@ import ( "net/url" "slices" "strings" + "time" ) // maxTreeFileSize is the maximum number of bytes we are willing to read from a // Merkle tree file referenced by a RootSet event. const maxTreeFileSize = 50 * 1024 * 1024 +// FetchTimeout bounds an entire tree file fetch. http.Client.Timeout spans +// the whole exchange — dialing, TLS, redirects, and reading the complete +// response body — so this must be long enough to download a tree file of up +// to maxTreeFileSize (50 MiB) from an allowed host, not just to receive the +// first byte. Tree files are served from hosts we control, so 10s is ample; +// on a timeout the event is redelivered by Kafka and the fetch is retried. +const FetchTimeout = 10 * time.Second + // TreeFetcher retrieves the Merkle tree file referenced by a RootSet event's // proofsURI. type TreeFetcher interface { diff --git a/internal/services/merkle/handler.go b/internal/services/merkle/handler.go index 0f44346f..c20a2dac 100644 --- a/internal/services/merkle/handler.go +++ b/internal/services/merkle/handler.go @@ -8,6 +8,7 @@ import ( "errors" "fmt" "math/big" + "time" "github.com/DIMO-Network/identity-api/internal/dbtypes" "github.com/DIMO-Network/identity-api/internal/helpers" @@ -20,6 +21,7 @@ import ( "github.com/aarondl/sqlboiler/v4/queries/qm" "github.com/ethereum/go-ethereum/common" "github.com/goccy/go-json" + "github.com/lib/pq" "github.com/rs/zerolog" ) @@ -191,11 +193,13 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat Str("week", args.Week.String()). Logger() + fetchStart := time.Now() data, err := h.Fetcher.Fetch(ctx, args.ProofsURI) if err != nil { logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Failed to fetch Merkle tree file.") return fmt.Errorf("fetching tree file: %w", err) } + fetchDuration := time.Since(fetchStart) file, err := merkletree.UnmarshalTreeFile(data) if err != nil { @@ -209,6 +213,14 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat } if file.Root != common.Hash(args.Root) { + // Returning an error here means the Kafka consumer never commits the + // offset for this event, so it will be redelivered and fail forever + // until the file at proofsURI is replaced with one matching the + // on-chain root. That is deliberate: a published tree file that + // disagrees with the root the contract accepted must page an + // operator, and the endless redelivery errors are the alerting + // mechanism. Skipping the event instead would silently leave the + // epoch's claims unindexed. err := fmt.Errorf("tree file root %s does not match event root %s", file.Root, common.Hash(args.Root)) logger.Err(err).Str("proofsURI", args.ProofsURI).Msg("Merkle tree file root mismatch.") return err @@ -224,6 +236,8 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat logger.Warn().Msgf("Tree file distributor %s does not match emitting contract %s.", file.Distributor, e.Contract) } + dbWriteStart := time.Now() + tx, err := h.DBS.DBS().Writer.BeginTx(ctx, nil) if err != nil { return err @@ -252,42 +266,50 @@ func (h *Handler) handleRootSet(ctx context.Context, e *cmodels.ContractEventDat return fmt.Errorf("upserting Merkle root: %w", err) } - claimCols := models.MerkleClaimColumns + accounts := make([][]byte, len(file.Leaves)) + amounts := make([]string, len(file.Leaves)) + proofs := make([]string, len(file.Leaves)) - for _, leaf := range file.Leaves { + for i, leaf := range file.Leaves { proof := make([]string, len(leaf.Proof)) - for i, p := range leaf.Proof { - proof[i] = p.Hex() + for j, p := range leaf.Proof { + proof[j] = p.Hex() } proofJSON, err := json.Marshal(proof) if err != nil { return fmt.Errorf("marshaling proof for account %s: %w", leaf.Account, err) } - claim := models.MerkleClaim{ - PoolID: root.PoolID, - Epoch: root.Epoch, - Account: leaf.Account.Bytes(), - Amount: dbtypes.IntToDecimal(leaf.Amount), - Proof: proofJSON, - } - - // Preserve claimed_at and claim_tx if the leaf was already claimed. - err = claim.Upsert(ctx, tx, true, - []string{claimCols.PoolID, claimCols.Epoch, claimCols.Account}, - boil.Whitelist(claimCols.Amount, claimCols.Proof), - boil.Infer(), - ) - if err != nil { - return fmt.Errorf("upserting Merkle claim for account %s: %w", leaf.Account, err) - } + accounts[i] = leaf.Account.Bytes() + amounts[i] = leaf.Amount.String() + proofs[i] = string(proofJSON) + } + + // Upsert all leaves in a single statement. Only amount and proof are in + // the SET list, so claimed_at and claim_tx are preserved if the root is + // set again after some leaves have already been claimed. + _, err = tx.ExecContext(ctx, + fmt.Sprintf(` + INSERT INTO %s (pool_id, epoch, account, amount, proof) + SELECT $1, $2, unnest($3::bytea[]), unnest($4::numeric[]), unnest($5::jsonb[]) + ON CONFLICT (pool_id, epoch, account) + DO UPDATE SET amount = EXCLUDED.amount, proof = EXCLUDED.proof`, + helpers.WithSchema(models.TableNames.MerkleClaims)), + root.PoolID, root.Epoch, pq.ByteaArray(accounts), pq.Array(amounts), pq.Array(proofs), + ) + if err != nil { + return fmt.Errorf("upserting Merkle claims: %w", err) } if err := tx.Commit(); err != nil { return err } - logger.Info().Int("recipientCount", len(file.Leaves)).Msg("Merkle root set.") + logger.Info(). + Int("recipientCount", len(file.Leaves)). + Int64("fetchDurationMs", fetchDuration.Milliseconds()). + Int64("dbWriteDurationMs", time.Since(dbWriteStart).Milliseconds()). + Msg("Merkle root set.") return nil } diff --git a/internal/services/merkle/handler_test.go b/internal/services/merkle/handler_test.go index 656b83cb..19ae792c 100644 --- a/internal/services/merkle/handler_test.go +++ b/internal/services/merkle/handler_test.go @@ -181,6 +181,29 @@ func TestHandleOverflowingArgumentsError(t *testing.T) { assert.ErrorContains(t, err, "does not fit in an int64") } +// TestRootSetDataWireFormat pins the wire format of the root argument: +// contract-event-processor decodes the indexed bytes32 with +// abi.ParseTopicsIntoMap, which yields a [32]byte that encoding/json +// serializes as an array of numbers, not a hex string. See the RootSetData +// docs before changing the field type. +func TestRootSetDataWireFormat(t *testing.T) { + raw := []byte(`{ + "poolId": 1, + "week": 2, + "root": [18,52,86,120,144,171,205,239,18,52,86,120,144,171,205,239,18,52,86,120,144,171,205,239,18,52,86,120,144,171,205,239], + "allocation": 600, + "proofsURI": "https://merkle.dimo.zone/pool-1/week-2.json" + }`) + + var args RootSetData + require.NoError(t, json.Unmarshal(raw, &args)) + + assert.Equal(t, common.HexToHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"), common.Hash(args.Root)) + assert.Equal(t, "1", args.PoolId.String()) + assert.Equal(t, "2", args.Week.String()) + assert.Equal(t, "600", args.Allocation.String()) +} + func TestHandleRootSet(t *testing.T) { tree, treeData := buildTree(t, 0, 214) uri := "https://merkle.dimo.zone/pool-0/week-214.json" @@ -231,6 +254,74 @@ func TestHandleRootSet(t *testing.T) { assert.Equal(t, expected, stored) } +// TestHandleRootSetManyLeaves exercises the single-statement batch upsert +// with well over a hundred leaves, including re-setting the root so the +// ON CONFLICT path runs for every row. +func TestHandleRootSetManyLeaves(t *testing.T) { + const leafCount = 150 + + leaves := make([]merkletree.Leaf, leafCount) + for i := range leaves { + var addr common.Address + addr[19] = byte(i + 1) + addr[18] = byte((i + 1) >> 8) + leaves[i] = merkletree.Leaf{Account: addr, Amount: big.NewInt(int64((i + 1) * 10))} + } + + tree, err := merkletree.New(distributorAddr, big.NewInt(0), big.NewInt(214), leaves) + require.NoError(t, err) + treeData, err := tree.MarshalJSON() + require.NoError(t, err) + + uri := "https://merkle.dimo.zone/pool-0/week-214.json" + + h, ctx := newTestHandler(t, &fakeFetcher{data: map[string][]byte{uri: treeData}}) + createPool(t, ctx, h, 0) + + rootSet := eventData(t, RootSet, time.Now(), RootSetData{ + PoolId: big.NewInt(0), + Week: big.NewInt(214), + Root: tree.Root(), + Allocation: big.NewInt(11325 * 10), + ProofsURI: uri, + }) + + require.NoError(t, h.Handle(ctx, rootSet)) + + count, err := models.MerkleClaims().Count(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.EqualValues(t, leafCount, count) + + dbRoot, err := models.FindMerkleRoot(ctx, h.DBS.DBS().Reader, 0, 214) + require.NoError(t, err) + assert.Equal(t, leafCount, dbRoot.RecipientCount) + + // Spot-check a leaf deep in the batch: amount and proof must round-trip. + target := leaves[137] + claim, err := models.FindMerkleClaim(ctx, h.DBS.DBS().Reader, 0, 214, target.Account.Bytes()) + require.NoError(t, err) + assert.Equal(t, target.Amount.String(), claim.Amount.Big.String()) + + proof, err := tree.Proof(target.Account) + require.NoError(t, err) + expected := make([]string, len(proof)) + for i, p := range proof { + expected[i] = p.Hex() + } + + var stored []string + require.NoError(t, json.Unmarshal(claim.Proof, &stored)) + assert.Equal(t, expected, stored) + + // Redelivery hits the ON CONFLICT branch for all rows and must not + // duplicate or fail. + require.NoError(t, h.Handle(ctx, rootSet)) + + count, err = models.MerkleClaims().Count(ctx, h.DBS.DBS().Reader) + require.NoError(t, err) + assert.EqualValues(t, leafCount, count) +} + func TestHandleRootSetTamperedFile(t *testing.T) { tree, treeData := buildTree(t, 0, 214) uri := "https://merkle.dimo.zone/pool-0/week-214.json" diff --git a/migrations/00049_create_merkle_tables.sql b/migrations/00049_create_merkle_tables.sql index 51ef9786..b9fd204a 100644 --- a/migrations/00049_create_merkle_tables.sql +++ b/migrations/00049_create_merkle_tables.sql @@ -34,7 +34,13 @@ CREATE TABLE merkle_claims ( CONSTRAINT merkle_claims_pool_id_epoch_fkey FOREIGN KEY (pool_id, epoch) REFERENCES merkle_roots (pool_id, epoch) ); -CREATE INDEX merkle_claims_account_idx ON merkle_claims (account); +-- Serves the merkleRewards query: filter by account (optionally pool), with +-- results and the pagination cursor ordered by (pool_id, epoch) descending. +CREATE INDEX merkle_claims_account_pool_epoch_idx ON merkle_claims (account, pool_id, epoch DESC); + +-- The hot query is "unclaimed rewards for an account"; the partial index +-- keeps it small since claimed rows dominate over time. +CREATE INDEX merkle_claims_account_claimed_idx ON merkle_claims (account) WHERE claimed_at IS NULL; -- +goose StatementEnd -- +goose Down From 59b97e18b33d03a961305a5269542634aa37dca4 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 15:41:57 -0400 Subject: [PATCH 09/11] feat(reward): include merkle-era claims in user earnings totals rewards(user).totalTokens now merges legacy per-device reward sums with merkle_claims amounts for the account, so user-level earnings keep growing after the merkle cutover. Merkle amounts count as earned at RootSet, claimed or not. History edges and totalCount stay legacy-only; per-epoch merkle data lives in the merkleRewards query. --- graph/model/models_gen.go | 12 +- graph/schema/reward.graphqls | 10 ++ internal/repositories/reward/rewards.go | 36 ++++- internal/repositories/reward/rewards_test.go | 138 +++++++++++++++++++ 4 files changed, 192 insertions(+), 4 deletions(-) diff --git a/graph/model/models_gen.go b/graph/model/models_gen.go index 6ce28fd6..ec001745 100644 --- a/graph/model/models_gen.go +++ b/graph/model/models_gen.go @@ -763,9 +763,15 @@ type TemplateEdge struct { } type UserRewards struct { - TotalTokens *decimal.Big `json:"totalTokens"` - History *EarningsConnection `json:"history"` - User common.Address `json:"-"` + // Total tokens earned by the user across both reward eras: legacy weekly + // device rewards plus merkle-era allocations. Merkle-era amounts count as + // earned when the root is set, whether or not they have been claimed. + TotalTokens *decimal.Big `json:"totalTokens"` + // Weekly earnings from the legacy reward era only, including totalCount. + // Merkle-era earnings are not itemized here; use the merkleRewards query + // for per-epoch merkle data. + History *EarningsConnection `json:"history"` + User common.Address `json:"-"` } type Vehicle struct { diff --git a/graph/schema/reward.graphqls b/graph/schema/reward.graphqls index 9a0e7e39..f5ac0103 100644 --- a/graph/schema/reward.graphqls +++ b/graph/schema/reward.graphqls @@ -68,7 +68,17 @@ type EarningsConnection { } type UserRewards { + """ + Total tokens earned by the user across both reward eras: legacy weekly + device rewards plus merkle-era allocations. Merkle-era amounts count as + earned when the root is set, whether or not they have been claimed. + """ totalTokens: BigDecimal! + """ + Weekly earnings from the legacy reward era only, including totalCount. + Merkle-era earnings are not itemized here; use the merkleRewards query + for per-epoch merkle data. + """ history( first: Int after: String diff --git a/internal/repositories/reward/rewards.go b/internal/repositories/reward/rewards.go index 8fe83558..86326662 100644 --- a/internal/repositories/reward/rewards.go +++ b/internal/repositories/reward/rewards.go @@ -248,23 +248,57 @@ func (r *Repository) PaginateAftermarketDeviceEarningsByID(ctx context.Context, return afterMarketDeviceEarnings.History, nil } +// GetEarningsByUserAddress returns user-level earnings totals for the given address. +// +// TotalTokens spans both reward eras: legacy per-device push rewards (rewards +// table) plus merkle-era allocations (merkle_claims). Merkle amounts count as +// earned when the root is set, whether or not the user has claimed them. +// +// History edges and TotalCount intentionally cover the legacy era only; the +// per-vehicle/per-device split does not exist in the merkle era. Merkle-era +// weekly data is exposed separately via the merkleRewards query. func (r *Repository) GetEarningsByUserAddress(ctx context.Context, user common.Address) (*gmodel.UserRewards, error) { summary, err := r.GetEarningsSummary(ctx, []qm.QueryMod{models.RewardWhere.ReceivedByAddress.EQ(null.BytesFrom(user.Bytes()))}) if err != nil { return nil, err } + merkleWei, err := r.getMerkleClaimsWeiSum(ctx, user) + if err != nil { + return nil, err + } + + totalWei := new(decimal.Big).Add(summary.TokenSum.Big, merkleWei) + earningsConn := &gmodel.EarningsConnection{ TotalCount: summary.TotalCount, } return &gmodel.UserRewards{ - TotalTokens: weiToToken(summary.TokenSum), + TotalTokens: new(decimal.Big).Quo(totalWei, weiPerEther), History: earningsConn, User: user, }, nil } +// getMerkleClaimsWeiSum sums merkle-era reward allocations, in wei, for the +// given account across all pools and epochs, claimed or not. +func (r *Repository) getMerkleClaimsWeiSum(ctx context.Context, account common.Address) (*decimal.Big, error) { + var out struct { + WeiSum types.Decimal `boil:"wei_sum"` + } + + err := models.MerkleClaims( + qm.Select("COALESCE(sum("+models.MerkleClaimColumns.Amount+"), 0) AS wei_sum"), + models.MerkleClaimWhere.Account.EQ(account.Bytes()), + ).Bind(ctx, r.PDB.DBS().Reader, &out) + if err != nil { + return nil, err + } + + return out.WeiSum.Big, nil +} + func (r *Repository) PaginateGetEarningsByUsersDevices(ctx context.Context, userDeviceEarnings *gmodel.UserRewards, first *int, after *string, last *int, before *string) (*gmodel.EarningsConnection, error) { limit, err := helpers.ValidateFirstLast(first, last, base.MaxPageSize) // return early if both first and last are provided if err != nil { diff --git a/internal/repositories/reward/rewards_test.go b/internal/repositories/reward/rewards_test.go index d85e3f2e..d69f1006 100644 --- a/internal/repositories/reward/rewards_test.go +++ b/internal/repositories/reward/rewards_test.go @@ -1679,6 +1679,144 @@ func (r *RewardsRepoTestSuite) Test_GetEarningsByUserAddress_MultipleVehicle_Fwd } +// createMerkleClaims seeds a merkle pool, one root per amount, and one claim +// per root for the given account. Even-indexed claims are left unclaimed and +// odd-indexed ones are marked claimed, since both must count toward earnings. +// Returns the total amount in wei. +func (r *RewardsRepoTestSuite) createMerkleClaims(account common.Address, amounts []*big.Int) *big.Int { + pool := models.MerklePool{ + PoolID: 1, + Token: common.HexToAddress("E261D618a959aFfFd53168Cd07D12E37B26761db").Bytes(), + Admin: common.HexToAddress("46a3A41bd932244Dd08186e4c19F1a7E48cbcDf4").Bytes(), + Balance: dbtypes.IntToDecimal(big.NewInt(0)), + CreatedAt: time.Now(), + } + r.NoError(pool.Insert(r.ctx, r.pdb.DBS().Writer, boil.Infer())) + + total := big.NewInt(0) + + for i, amount := range amounts { + epoch := 213 + i + + root := models.MerkleRoot{ + PoolID: 1, + Epoch: epoch, + Root: common.HexToHash("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Bytes(), + Allocation: dbtypes.IntToDecimal(amount), + RecipientCount: 1, + ProofsURI: fmt.Sprintf("https://merkle.dimo.zone/pool-1/week-%d.json", epoch), + SetAt: time.Now(), + } + r.NoError(root.Insert(r.ctx, r.pdb.DBS().Writer, boil.Infer())) + + claim := models.MerkleClaim{ + PoolID: 1, + Epoch: epoch, + Account: account.Bytes(), + Amount: dbtypes.IntToDecimal(amount), + Proof: types.JSON(`["0x1111111111111111111111111111111111111111111111111111111111111111"]`), + } + if i%2 == 1 { + claim.ClaimedAt = null.TimeFrom(time.Now()) + } + r.NoError(claim.Insert(r.ctx, r.pdb.DBS().Writer, boil.Infer())) + + total.Add(total, amount) + } + + return total +} + +func (r *RewardsRepoTestSuite) Test_GetEarningsByUserAddress_MergesLegacyAndMerkle() { + _, beneficiary, err := helpers.GenerateWallet() + r.NoError(err) + + currTime := time.Now().UTC().Truncate(time.Second) + + r.createDependentRecords() + + legacyEarned := big.NewInt(0) + + rw, err := r.createRewardsRecords(2, createRewardsRecordsInput{ + beneficiary: *beneficiary, + dateTime: currTime, + afterMarketDeviceID: 1, + }) + r.NoError(err) + + for _, rr := range rw { + baseAmt, ok := new(big.Int).SetString("59147051345528509681", 10) + r.NotZero(ok) + + aftEarn := new(big.Int).Add(baseAmt, big.NewInt(30)) + strkEarn := new(big.Int).Add(baseAmt, big.NewInt(50)) + syntEarn := new(big.Int).Add(baseAmt, big.NewInt(10)) + + rr.AftermarketEarnings = dbtypes.IntToDecimal(aftEarn) + rr.StreakEarnings = dbtypes.IntToDecimal(strkEarn) + rr.SyntheticEarnings = dbtypes.IntToDecimal(syntEarn) + + legacyEarned.Add(legacyEarned, aftEarn) + legacyEarned.Add(legacyEarned, strkEarn) + legacyEarned.Add(legacyEarned, syntEarn) + + err = rr.Insert(r.ctx, r.pdb.DBS().Writer, boil.Infer()) + r.NoError(err) + } + + amount1, ok := new(big.Int).SetString("41000000000000000000", 10) + r.True(ok) + amount2, ok := new(big.Int).SetString("17500000000000000000", 10) + r.True(ok) + + merkleEarned := r.createMerkleClaims(*beneficiary, []*big.Int{amount1, amount2}) + + rwrd, err := r.repo.GetEarningsByUserAddress(r.ctx, *beneficiary) + r.NoError(err) + + expected := bigWeiToToken(new(big.Int).Add(legacyEarned, merkleEarned)) + r.Zero(rwrd.TotalTokens.Cmp(expected), "totalTokens = %s, want %s", rwrd.TotalTokens, expected) + + // History remains legacy-only: totalCount counts only legacy reward rows. + r.Equal(2, rwrd.History.TotalCount) +} + +func (r *RewardsRepoTestSuite) Test_GetEarningsByUserAddress_MerkleOnly() { + _, beneficiary, err := helpers.GenerateWallet() + r.NoError(err) + + amount1, ok := new(big.Int).SetString("63000000000000000000", 10) + r.True(ok) + amount2, ok := new(big.Int).SetString("9250000000000000000", 10) + r.True(ok) + + merkleEarned := r.createMerkleClaims(*beneficiary, []*big.Int{amount1, amount2}) + + rwrd, err := r.repo.GetEarningsByUserAddress(r.ctx, *beneficiary) + r.NoError(err) + + expected := bigWeiToToken(merkleEarned) + r.Zero(rwrd.TotalTokens.Cmp(expected), "totalTokens = %s, want %s", rwrd.TotalTokens, expected) + r.Equal(0, rwrd.History.TotalCount) + + first := 10 + paginatedEarnings, err := r.repo.PaginateGetEarningsByUsersDevices(r.ctx, rwrd, &first, nil, nil, nil) + r.NoError(err) + r.Empty(paginatedEarnings.Edges) + r.Empty(paginatedEarnings.Nodes) +} + +func (r *RewardsRepoTestSuite) Test_GetEarningsByUserAddress_NoEarnings() { + _, beneficiary, err := helpers.GenerateWallet() + r.NoError(err) + + rwrd, err := r.repo.GetEarningsByUserAddress(r.ctx, *beneficiary) + r.NoError(err) + + r.Zero(rwrd.TotalTokens.Cmp(decimal.New(0, 0)), "totalTokens = %s, want 0", rwrd.TotalTokens) + r.Equal(0, rwrd.History.TotalCount) +} + func bigWeiToToken(wei *big.Int) *decimal.Big { bigDec := new(decimal.Big).SetBigMantScale(wei, 0) return weiToToken(types.NewDecimal(bigDec)) From eadec829610bce925b2dcf569621006be1bd7ac1 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 22:26:41 -0400 Subject: [PATCH 10/11] style: satisfy staticcheck in merkle handler and tests --- internal/services/merkle/handler.go | 6 +++--- internal/services/merkle/handler_test.go | 22 +++++++++++----------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/internal/services/merkle/handler.go b/internal/services/merkle/handler.go index c20a2dac..44fda499 100644 --- a/internal/services/merkle/handler.go +++ b/internal/services/merkle/handler.go @@ -149,7 +149,7 @@ func (h *Handler) handleFunded(ctx context.Context, e *cmodels.ContractEventData return err } if rowsAff == 0 { - return fmt.Errorf("Funded for unknown pool %d", args.PoolId) + return fmt.Errorf("funded event for unknown pool %d", args.PoolId) } return nil @@ -171,7 +171,7 @@ func (h *Handler) handleSwept(ctx context.Context, e *cmodels.ContractEventData, return err } if rowsAff == 0 { - return fmt.Errorf("Swept for unknown pool %d", pool.PoolID) + return fmt.Errorf("swept event for unknown pool %d", pool.PoolID) } return nil @@ -338,7 +338,7 @@ func (h *Handler) handleClaimed(ctx context.Context, e *cmodels.ContractEventDat ).One(ctx, tx) if err != nil { if errors.Is(err, sql.ErrNoRows) { - return fmt.Errorf("Claimed for unknown leaf: pool %d, epoch %d, account %s", poolID, epoch, args.Account) + return fmt.Errorf("claimed event for unknown leaf: pool %d, epoch %d, account %s", poolID, epoch, args.Account) } return err } diff --git a/internal/services/merkle/handler_test.go b/internal/services/merkle/handler_test.go index 19ae792c..09bf9010 100644 --- a/internal/services/merkle/handler_test.go +++ b/internal/services/merkle/handler_test.go @@ -112,8 +112,8 @@ func TestHandlePoolCreatedAndBalanceEvents(t *testing.T) { require.NoError(t, err) assert.Equal(t, tokenAddr.Bytes(), pool.Token) assert.Equal(t, adminAddr.Bytes(), pool.Admin) - assert.Equal(t, "5000", pool.WeeklyLimit.Big.String()) - assert.Equal(t, "0", pool.Balance.Big.String()) + assert.Equal(t, "5000", pool.WeeklyLimit.String()) + assert.Equal(t, "0", pool.Balance.String()) assert.WithinDuration(t, createdAt, pool.CreatedAt, time.Second) // WeeklyLimitSet updates the limit. @@ -132,8 +132,8 @@ func TestHandlePoolCreatedAndBalanceEvents(t *testing.T) { require.NoError(t, err) require.NoError(t, pool.Reload(ctx, h.DBS.DBS().Reader)) - assert.Equal(t, "7000", pool.WeeklyLimit.Big.String()) - assert.Equal(t, "1000", pool.Balance.Big.String()) + assert.Equal(t, "7000", pool.WeeklyLimit.String()) + assert.Equal(t, "1000", pool.Balance.String()) // Swept sets the balance to the new absolute value. err = h.Handle(ctx, eventData(t, Swept, time.Now(), SweptData{ @@ -145,7 +145,7 @@ func TestHandlePoolCreatedAndBalanceEvents(t *testing.T) { require.NoError(t, err) require.NoError(t, pool.Reload(ctx, h.DBS.DBS().Reader)) - assert.Equal(t, "400", pool.Balance.Big.String()) + assert.Equal(t, "400", pool.Balance.String()) // Balance events for unknown pools are errors. err = h.Handle(ctx, eventData(t, Funded, time.Now(), FundedData{ @@ -226,10 +226,10 @@ func TestHandleRootSet(t *testing.T) { dbRoot, err := models.FindMerkleRoot(ctx, h.DBS.DBS().Reader, 0, 214) require.NoError(t, err) assert.Equal(t, root[:], dbRoot.Root) - assert.Equal(t, "600", dbRoot.Allocation.Big.String()) + assert.Equal(t, "600", dbRoot.Allocation.String()) assert.Equal(t, 3, dbRoot.RecipientCount) assert.Equal(t, 0, dbRoot.ClaimCount) - assert.Equal(t, "0", dbRoot.TotalClaimed.Big.String()) + assert.Equal(t, "0", dbRoot.TotalClaimed.String()) assert.Equal(t, uri, dbRoot.ProofsURI) assert.WithinDuration(t, setAt, dbRoot.SetAt, time.Second) @@ -239,7 +239,7 @@ func TestHandleRootSet(t *testing.T) { claim, err := models.FindMerkleClaim(ctx, h.DBS.DBS().Reader, 0, 214, account1.Bytes()) require.NoError(t, err) - assert.Equal(t, "100", claim.Amount.Big.String()) + assert.Equal(t, "100", claim.Amount.String()) assert.False(t, claim.ClaimedAt.Valid) proof, err := tree.Proof(account1) @@ -300,7 +300,7 @@ func TestHandleRootSetManyLeaves(t *testing.T) { target := leaves[137] claim, err := models.FindMerkleClaim(ctx, h.DBS.DBS().Reader, 0, 214, target.Account.Bytes()) require.NoError(t, err) - assert.Equal(t, target.Amount.String(), claim.Amount.Big.String()) + assert.Equal(t, target.Amount.String(), claim.Amount.String()) proof, err := tree.Proof(target.Account) require.NoError(t, err) @@ -421,11 +421,11 @@ func TestHandleClaimedIdempotent(t *testing.T) { root, err := models.FindMerkleRoot(ctx, h.DBS.DBS().Reader, 0, 214) require.NoError(t, err) assert.Equal(t, 1, root.ClaimCount) - assert.Equal(t, "100", root.TotalClaimed.Big.String()) + assert.Equal(t, "100", root.TotalClaimed.String()) pool, err := models.FindMerklePool(ctx, h.DBS.DBS().Reader, 0) require.NoError(t, err) - assert.Equal(t, "900", pool.Balance.Big.String()) + assert.Equal(t, "900", pool.Balance.String()) } checkState() From cf6065cee4818a8e10858d9c32288274dec77c61 Mon Sep 17 00:00:00 2001 From: zer0stars <74260741+zer0stars@users.noreply.github.com> Date: Wed, 10 Jun 2026 22:27:32 -0400 Subject: [PATCH 11/11] style: drop redundant embedded Big selectors --- internal/repositories/merkle/merkle.go | 4 ++-- internal/services/merkle_consumer_test.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/internal/repositories/merkle/merkle.go b/internal/repositories/merkle/merkle.go index 18e369fd..8aa183ed 100644 --- a/internal/repositories/merkle/merkle.go +++ b/internal/repositories/merkle/merkle.go @@ -35,7 +35,7 @@ type RewardCursor struct { var rewardCursorColumns = "(" + models.MerkleClaimColumns.PoolID + ", " + models.MerkleClaimColumns.Epoch + ")" func decimalToBig(d types.Decimal) *big.Int { - return d.Big.Int(nil) + return d.Int(nil) } // PoolToAPI converts a database Merkle pool row to its GraphQL form. @@ -49,7 +49,7 @@ func PoolToAPI(pool *models.MerklePool) *gmodel.MerklePool { } if pool.WeeklyLimit.Big != nil { - out.WeeklyLimit = pool.WeeklyLimit.Big.Int(nil) + out.WeeklyLimit = pool.WeeklyLimit.Int(nil) } return out diff --git a/internal/services/merkle_consumer_test.go b/internal/services/merkle_consumer_test.go index b80df106..67e53821 100644 --- a/internal/services/merkle_consumer_test.go +++ b/internal/services/merkle_consumer_test.go @@ -52,6 +52,6 @@ func TestHandleMerklePoolCreatedEvent(t *testing.T) { require.NoError(t, err) assert.Equal(t, args.Token.Bytes(), pool.Token) assert.Equal(t, args.Admin.Bytes(), pool.Admin) - assert.Equal(t, "5000", pool.WeeklyLimit.Big.String()) - assert.Equal(t, "0", pool.Balance.Big.String()) + assert.Equal(t, "5000", pool.WeeklyLimit.String()) + assert.Equal(t, "0", pool.Balance.String()) }