MPC Tally API Server
# Tally API Types Reference
This document provides a comprehensive list of types and their descriptions for the Tally API. It is intended to be used by Large Language Models (LLMs) to understand the available data structures.
**Types:**
```graphql
type Account {
id: ID!
address: String!
ens: String
twitter: String
name: String!
bio: String!
picture: String
safes: [AccountID!]
type: AccountType!
votes(governorId: AccountID!): Uint256!
proposalsCreatedCount(input: ProposalsCreatedCountInput!): Int!
}
# AccountID: A CAIP-10 compliant account id. (e.g., "eip155:1:0x7e90e03654732abedf89Faf87f05BcD03ACEeFdc")
scalar AccountID
# AccountType: An enum indicating the type of account (EOA or SAFE)
enum AccountType {
EOA
SAFE
}
# Address: A 20 byte Ethereum address, represented as 0x-prefixed hexadecimal. (e.g., "0x1234567800000000000000000000000000000abc")
scalar Address
type Allocation {
account: Account!
amount: Uint256!
percent: Float!
}
# Any: A scalar type to represent any data
scalar Any
# AssetID: A CAIP-19 compliant asset id. (e.g., "eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f")
scalar AssetID
type Block {
id: BlockID!
number: Int!
timestamp: Timestamp!
ts: Timestamp!
}
# BlockID: A ChainID scoped identifier for identifying blocks across chains. Ex: eip155:1:15672.
scalar BlockID
# BlockOrTimestamp: A union type that represents either a Block or a BlocklessTimestamp.
union BlockOrTimestamp = Block | BlocklessTimestamp
type BlocklessTimestamp {
timestamp: Timestamp!
}
# Boolean: Represents a `true` or `false` value.
scalar Boolean
# Bytes: An arbitrary length binary string, represented as 0x-prefixed hexadecimal. (e.g., "0x4321abcd").
scalar Bytes
type Chain {
id: ChainID!
layer1Id: ChainID
name: String!
mediumName: String!
shortName: String!
blockTime: Float!
isTestnet: Boolean!
nativeCurrency: NativeCurrency!
chain: String!
useLayer1VotingPeriod: Boolean!
}
# ChainID: CAIP-2 compliant chain id. (e.g., "eip155:1").
scalar ChainID
type CompetencyFieldDescriptor {
id: IntID!
name: String!
description: String!
}
type Contracts {
governor: GovernorContract!
tokens: [TokenContract!]!
}
type Contributor {
id: IntID!
account: Account!
isCurator: Boolean!
isApplyingForCouncil: Boolean!
competencyFieldDescriptors: [CompetencyFieldDescriptor!]!
bio: UserBio!
}
type DataDecoded {
method: String!
parameters: [Parameter!]!
}
# Date: A date in the format ISO 8601 format, e.g. YYYY-MM-DD. (e.g., "2022-09-22")
scalar Date
type DecodedCalldata {
signature: String!
parameters: [DecodedParameter!]!
}
type DecodedParameter {
name: String!
type: String!
value: String!
}
type Delegate {
id: IntID!
account: Account!
chainId: ChainID
delegatorsCount: Int!
governor: Governor
organization: Organization
statement: DelegateStatement
token: Token
votesCount(blockNumber: Int): Uint256!
}
input DelegateInput {
address: Address!
governorId: AccountID
organizationId: IntID
}
type DelegateStatement {
id: IntID!
address: Address!
organizationID: IntID!
statement: String!
statementSummary: String
isSeekingDelegation: Boolean
issues: [Issue!]
}
input DelegatesFiltersInput {
address: Address
governorId: AccountID
hasVotes: Boolean
hasDelegators: Boolean
issueIds: [IntID!]
isSeekingDelegation: Boolean
organizationId: IntID
}
input DelegatesInput {
filters: DelegatesFiltersInput!
page: PageInput
sort: DelegatesSortInput
}
enum DelegatesSortBy {
id
votes
delegators
prioritized
}
input DelegatesSortInput {
isDescending: Boolean!
sortBy: DelegatesSortBy!
}
type Delegation {
id: IntID!
blockNumber: Int!
blockTimestamp: Timestamp!
chainId: ChainID!
delegator: Account!
delegate: Account!
organization: Organization!
token: Token!
votes: Uint256!
}
input DelegationInput {
address: Address!
tokenId: AssetID!
}
input DelegationsFiltersInput {
address: Address!
governorId: AccountID
organizationId: IntID
}
input DelegationsInput {
filters: DelegationsFiltersInput!
page: PageInput
sort: DelegationsSortInput
}
enum DelegationsSortBy {
id
votes
}
input DelegationsSortInput {
isDescending: Boolean!
sortBy: DelegationsSortBy!
}
type Eligibility {
status: EligibilityStatus!
proof: [String!]
amount: Uint256
tx: HashID
}
enum EligibilityStatus {
NOTELIGIBLE
ELIGIBLE
CLAIMED
}
type EndorsementService {
id: IntID!
competencyFields: [CompetencyFieldDescriptor!]!
}
type ExecutableCall {
calldata: Bytes!
chainId: ChainID!
index: Int!
signature: String
target: Address!
type: ExecutableCallType
value: Uint256!
decodedCalldata: DecodedCalldata
}
enum ExecutableCallType {
custom
erc20transfer
erc20transferarbitrum
empty
nativetransfer
orcamanagepod
other
reward
swap
}
# Float: A signed double-precision fractional values as specified by IEEE 754. (e.g., 987.65)
scalar Float
type Governor {
id: AccountID!
chainId: ChainID!
contracts: Contracts!
isIndexing: Boolean!
isBehind: Boolean!
isPrimary: Boolean!
kind: GovernorKind!
name: String!
organization: Organization!
proposalStats: ProposalStats!
parameters: GovernorParameters!
quorum: Uint256!
slug: String!
timelockId: AccountID
tokenId: AssetID!
token: Token!
type: GovernorType!
delegatesCount: Int!
delegatesVotesCount: Uint256!
tokenOwnersCount: Int!
metadata: GovernorMetadata
}
type GovernorContract {
address: Address!
type: GovernorType!
}
input GovernorInput {
id: AccountID
slug: String
}
enum GovernorKind {
single
multiprimary
multisecondary
multiother
hub
spoke
}
type GovernorMetadata {
description: String
}
type GovernorParameters {
quorumVotes: Uint256
proposalThreshold: Uint256
votingDelay: Uint256
votingPeriod: Uint256
gracePeriod: Uint256
quorumNumerator: Uint256
quorumDenominator: Uint256
clockMode: String
nomineeVettingDuration: Uint256
fullWeightDuration: Uint256
}
enum GovernorType {
governoralpha
governorbravo
openzeppelingovernor
aave
nounsfork
nomineeelection
memberelection
hub
spoke
}
input GovernorsFiltersInput {
organizationId: IntID!
includeInactive: Boolean
excludeSecondary: Boolean
}
input GovernorsInput {
filters: GovernorsFiltersInput
page: PageInput
sort: GovernorsSortInput
}
enum GovernorsSortBy {
id
}
input GovernorsSortInput {
isDescending: Boolean!
sortBy: GovernorsSortBy!
}
# Hash: For identifying transactions on a chain. Ex: 0xDEAD.
scalar Hash
# HashID: A ChainID scoped identifier for identifying transactions across chains. Ex: eip155:1:0xDEAD.
scalar HashID
# ID: The ID scalar type represents a unique identifier
scalar ID
# Int: The Int scalar type represents non-fractional signed whole numeric values.
scalar Int
# IntID: A 64bit integer as a string - this is larger than Javascript's number.
scalar IntID
type Issue {
id: IntID!
organizationId: IntID!
name: String!
description: String!
}
type Member {
id: ID!
account: Account!
organization: Organization!
}
type NativeCurrency {
name: String!
symbol: String!
decimals: Int!
}
# Node: Union of all node types that are paginated.
union Node =
| Delegate
| Organization
| Member
| Delegation
| Governor
| Proposal
| Vote
| StakeEvent
| StakeEarning
| Contributor
| Allocation
type Organization {
id: IntID!
slug: String!
name: String!
chainIds: [ChainID!]!
tokenIds: [AssetID!]!
governorIds: [AccountID!]!
metadata: OrganizationMetadata
creator: Account
hasActiveProposals: Boolean!
proposalsCount: Int!
delegatesCount: Int!
delegatesVotesCount: Uint256!
tokenOwnersCount: Int!
endorsementService: EndorsementService
}
input OrganizationInput {
id: IntID
slug: String
}
type OrganizationMetadata {
color: String
description: String
icon: String
socials: Socials
karmaName: String
}
input OrganizationsFiltersInput {
address: Address
chainId: ChainID
hasLogo: Boolean
isMember: Boolean
}
input OrganizationsInput {
filters: OrganizationsFiltersInput
page: PageInput
sort: OrganizationsSortInput
}
enum OrganizationsSortBy {
id
name
explore
popular
}
input OrganizationsSortInput {
isDescending: Boolean!
sortBy: OrganizationsSortBy!
}
type PageInfo {
firstCursor: String
lastCursor: String
count: Int
}
input PageInput {
afterCursor: String
beforeCursor: String
limit: Int
}
# PaginatedOutput: Wraps a list of nodes and the pagination info
type PaginatedOutput {
nodes: [Node!]!
pageInfo: PageInfo!
}
type Parameter {
name: String!
type: String!
value: Any!
valueDecoded: [ValueDecoded!]
}
type Proposal {
id: IntID!
onchainId: String
block: Block
chainId: ChainID!
creator: Account
end: BlockOrTimestamp!
events: [ProposalEvent!]!
executableCalls: [ExecutableCall!]
governor: Governor!
metadata: ProposalMetadata!
organization: Organization!
proposer: Account
quorum: Uint256
status: ProposalStatus!
start: BlockOrTimestamp!
voteStats: [VoteStats!]
}
type ProposalEvent {
block: Block!
chainId: ChainID!
createdAt: Timestamp!
type: ProposalEventType!
txHash: Hash!
}
enum ProposalEventType {
activated
canceled
created
defeated
drafted
executed
expired
extended
pendingexecution
queued
succeeded
callexecuted
crosschainexecuted
}
input ProposalInput {
id: IntID
onchainId: String
governorId: AccountID
includeArchived: Boolean
isLatest: Boolean
}
type ProposalMetadata {
title: String
description: String
eta: Int
ipfsHash: String
previousEnd: Int
timelockId: AccountID
txHash: Hash
discourseURL: String
snapshotURL: String
}
type ProposalStats {
total: Int!
active: Int!
failed: Int!
passed: Int!
}
enum ProposalStatus {
active
archived
canceled
callexecuted
defeated
draft
executed
expired
extended
pending
queued
pendingexecution
submitted
succeeded
crosschainexecuted
}
input ProposalsCreatedCountInput {
governorId: AccountID
organizationId: IntID
}
input ProposalsFiltersInput {
governorId: AccountID
includeArchived: Boolean
isDraft: Boolean
organizationId: IntID
proposer: Address
}
input ProposalsInput {
filters: ProposalsFiltersInput
page: PageInput
sort: ProposalsSortInput
}
enum ProposalsSortBy {
id
}
input ProposalsSortInput {
isDescending: Boolean!
sortBy: ProposalsSortBy!
}
enum Role {
ADMIN
USER
}
type StakeEarning {
amount: Uint256!
date: Date!
}
type StakeEvent {
amount: Uint256!
block: Block!
type: StakeEventType!
}
enum StakeEventType {
deposit
withdraw
}
# String: The String scalar type represents textual data, represented as UTF-8 character sequences
scalar String
# Timestamp: Timestamp is an RFC3339 string.
scalar Timestamp
type Token {
id: AssetID!
type: TokenType!
name: String!
symbol: String!
supply: Uint256!
decimals: Int!
eligibility: Eligibility
isIndexing: Boolean!
isBehind: Boolean!
}
type TokenContract {
address: Address!
type: TokenType!
}
input TokenInput {
id: AssetID!
}
enum TokenType {
ERC20
ERC721
ERC20AAVE
SOLANASPOKETOKEN
}
# Uint256: Uint256 is a large unsigned integer represented as a string.
scalar Uint256
type UserBio {
value: String!
summary: String!
}
type ValueDecoded {
operation: Int!
to: String!
value: String!
data: String!
dataDecoded: DataDecoded
}
type Vote {
id: IntID!
amount: Uint256!
block: Block!
chainId: ChainID!
isBridged: Boolean
proposal: Proposal!
reason: String
type: VoteType!
txHash: Hash!
voter: Account!
}
type VoteStats {
type: VoteType!
votesCount: Uint256!
votersCount: Int!
percent: Float!
}
enum VoteType {
abstain
against
for
pendingabstain
pendingagainst
pendingfor
}
input VotesFiltersInput {
proposalId: IntID
proposalIds: [IntID!]
voter: Address
includePendingVotes: Boolean
type: VoteType
}
input VotesInput {
filters: VotesFiltersInput
page: PageInput
sort: VotesSortInput
}
enum VotesSortBy {
id
amount
}
input VotesSortInput {
isDescending: Boolean!
sortBy: VotesSortBy!
}