envio 3.6.0 → 3.6.1-subgraph

package/src/subgraph/graph-ts-types/chain/cosmos.d.ts

@@ -0,0 +1,327 @@
+import '../common/eager-offset';
+import { Bytes } from '../common/collections';
+export declare namespace cosmos {
+    class Block {
+        header: Header;
+        evidence: EvidenceList;
+        lastCommit: Commit;
+        resultBeginBlock: ResponseBeginBlock;
+        resultEndBlock: ResponseEndBlock;
+        transactions: Array<TxResult>;
+        validatorUpdates: Array<Validator>;
+        constructor(header: Header, evidence: EvidenceList, lastCommit: Commit, resultBeginBlock: ResponseBeginBlock, resultEndBlock: ResponseEndBlock, transactions: Array<TxResult>, validatorUpdates: Array<Validator>);
+    }
+    class HeaderOnlyBlock {
+        header: Header;
+        constructor(header: Header);
+    }
+    class EventData {
+        event: Event;
+        block: HeaderOnlyBlock;
+        tx: TransactionContext;
+        constructor(event: Event, block: HeaderOnlyBlock, tx: TransactionContext);
+    }
+    class TransactionData {
+        tx: TxResult;
+        block: HeaderOnlyBlock;
+        constructor(tx: TxResult, block: HeaderOnlyBlock);
+    }
+    class MessageData {
+        message: Any;
+        block: HeaderOnlyBlock;
+        tx: TransactionContext;
+        constructor(message: Any, block: HeaderOnlyBlock, tx: TransactionContext);
+    }
+    class TransactionContext {
+        hash: Bytes;
+        index: number;
+        code: number;
+        gasWanted: bigint;
+        gasUsed: bigint;
+        constructor(hash: Bytes, index: number, code: number, gasWanted: bigint, gasUsed: bigint);
+    }
+    class Header {
+        version: Consensus;
+        chainId: string;
+        height: bigint;
+        time: Timestamp;
+        lastBlockId: BlockID;
+        lastCommitHash: Bytes;
+        dataHash: Bytes;
+        validatorsHash: Bytes;
+        nextValidatorsHash: Bytes;
+        consensusHash: Bytes;
+        appHash: Bytes;
+        lastResultsHash: Bytes;
+        evidenceHash: Bytes;
+        proposerAddress: Bytes;
+        hash: Bytes;
+        constructor(version: Consensus, chainId: string, height: bigint, time: Timestamp, lastBlockId: BlockID, lastCommitHash: Bytes, dataHash: Bytes, validatorsHash: Bytes, nextValidatorsHash: Bytes, consensusHash: Bytes, appHash: Bytes, lastResultsHash: Bytes, evidenceHash: Bytes, proposerAddress: Bytes, hash: Bytes);
+    }
+    class Consensus {
+        block: bigint;
+        app: bigint;
+        constructor(block: bigint, app: bigint);
+    }
+    class Timestamp {
+        seconds: bigint;
+        nanos: number;
+        constructor(seconds: bigint, nanos: number);
+    }
+    class BlockID {
+        hash: Bytes;
+        partSetHeader: PartSetHeader;
+        constructor(hash: Bytes, partSetHeader: PartSetHeader);
+    }
+    class PartSetHeader {
+        total: number;
+        hash: Bytes;
+        constructor(total: number, hash: Bytes);
+    }
+    class EvidenceList {
+        evidence: Array<Evidence>;
+        constructor(evidence: Array<Evidence>);
+    }
+    class Evidence {
+        duplicateVoteEvidence: DuplicateVoteEvidence;
+        lightClientAttackEvidence: LightClientAttackEvidence;
+        constructor(duplicateVoteEvidence: DuplicateVoteEvidence, lightClientAttackEvidence: LightClientAttackEvidence);
+    }
+    class DuplicateVoteEvidence {
+        voteA: EventVote;
+        voteB: EventVote;
+        totalVotingPower: bigint;
+        validatorPower: bigint;
+        timestamp: Timestamp;
+        constructor(voteA: EventVote, voteB: EventVote, totalVotingPower: bigint, validatorPower: bigint, timestamp: Timestamp);
+    }
+    class EventVote {
+        eventVoteType: SignedMsgType;
+        height: bigint;
+        round: number;
+        blockId: BlockID;
+        timestamp: Timestamp;
+        validatorAddress: Bytes;
+        validatorIndex: number;
+        signature: Bytes;
+        constructor(eventVoteType: SignedMsgType, height: bigint, round: number, blockId: BlockID, timestamp: Timestamp, validatorAddress: Bytes, validatorIndex: number, signature: Bytes);
+    }
+    enum SignedMsgType {
+        SIGNED_MSG_TYPE_UNKNOWN = 0,
+        SIGNED_MSG_TYPE_PREVOTE = 1,
+        SIGNED_MSG_TYPE_PRECOMMIT = 2,
+        SIGNED_MSG_TYPE_PROPOSAL = 32
+    }
+    class LightClientAttackEvidence {
+        conflictingBlock: LightBlock;
+        commonHeight: bigint;
+        byzantineValidators: Array<Validator>;
+        totalVotingPower: bigint;
+        timestamp: Timestamp;
+        constructor(conflictingBlock: LightBlock, commonHeight: bigint, byzantineValidators: Array<Validator>, totalVotingPower: bigint, timestamp: Timestamp);
+    }
+    class LightBlock {
+        signedHeader: SignedHeader;
+        validatorSet: ValidatorSet;
+        constructor(signedHeader: SignedHeader, validatorSet: ValidatorSet);
+    }
+    class SignedHeader {
+        header: Header;
+        commit: Commit;
+        constructor(header: Header, commit: Commit);
+    }
+    class Commit {
+        height: bigint;
+        round: number;
+        blockId: BlockID;
+        signatures: Array<CommitSig>;
+        constructor(height: bigint, round: number, blockId: BlockID, signatures: Array<CommitSig>);
+    }
+    class CommitSig {
+        blockIdFlag: BlockIDFlag;
+        validatorAddress: Bytes;
+        timestamp: Timestamp;
+        signature: Bytes;
+        constructor(blockIdFlag: BlockIDFlag, validatorAddress: Bytes, timestamp: Timestamp, signature: Bytes);
+    }
+    enum BlockIDFlag {
+        BLOCK_ID_FLAG_UNKNOWN = 0,
+        BLOCK_ID_FLAG_ABSENT = 1,
+        BLOCK_ID_FLAG_COMMIT = 2,
+        BLOCK_ID_FLAG_NIL = 3
+    }
+    class ValidatorSet {
+        validators: Array<Validator>;
+        proposer: Validator;
+        totalVotingPower: bigint;
+        constructor(validators: Array<Validator>, proposer: Validator, totalVotingPower: bigint);
+    }
+    class Validator {
+        address: Bytes;
+        pubKey: PublicKey;
+        votingPower: bigint;
+        proposerPriority: bigint;
+        constructor(address: Bytes, pubKey: PublicKey, votingPower: bigint, proposerPriority: bigint);
+    }
+    class PublicKey {
+        ed25519: Bytes;
+        secp256k1: Bytes;
+        constructor(ed25519: Bytes, secp256k1: Bytes);
+    }
+    class ResponseBeginBlock {
+        events: Array<Event>;
+        constructor(events: Array<Event>);
+    }
+    class Event {
+        eventType: string;
+        attributes: Array<EventAttribute>;
+        constructor(eventType: string, attributes: Array<EventAttribute>);
+        getAttribute(key: string): EventAttribute | null;
+        getAttributeValue(key: string): string;
+    }
+    class EventAttribute {
+        key: string;
+        value: string;
+        index: boolean;
+        constructor(key: string, value: string, index: boolean);
+    }
+    class ResponseEndBlock {
+        validatorUpdates: Array<ValidatorUpdate>;
+        consensusParamUpdates: ConsensusParams;
+        events: Array<Event>;
+        constructor(validatorUpdates: Array<ValidatorUpdate>, consensusParamUpdates: ConsensusParams, events: Array<Event>);
+    }
+    class ValidatorUpdate {
+        address: Bytes;
+        pubKey: PublicKey;
+        power: bigint;
+        constructor(address: Bytes, pubKey: PublicKey, power: bigint);
+    }
+    class ConsensusParams {
+        block: BlockParams;
+        evidence: EvidenceParams;
+        validator: ValidatorParams;
+        version: VersionParams;
+        constructor(block: BlockParams, evidence: EvidenceParams, validator: ValidatorParams, version: VersionParams);
+    }
+    class BlockParams {
+        maxBytes: bigint;
+        maxGas: bigint;
+        constructor(maxBytes: bigint, maxGas: bigint);
+    }
+    class EvidenceParams {
+        maxAgeNumBlocks: bigint;
+        maxAgeDuration: Duration;
+        maxBytes: bigint;
+        constructor(maxAgeNumBlocks: bigint, maxAgeDuration: Duration, maxBytes: bigint);
+    }
+    class Duration {
+        seconds: bigint;
+        nanos: number;
+        constructor(seconds: bigint, nanos: number);
+    }
+    class ValidatorParams {
+        pubKeyTypes: Array<string>;
+        constructor(pubKeyTypes: Array<string>);
+    }
+    class VersionParams {
+        appVersion: bigint;
+        constructor(appVersion: bigint);
+    }
+    class TxResult {
+        height: bigint;
+        index: number;
+        tx: Tx;
+        result: ResponseDeliverTx;
+        hash: Bytes;
+        constructor(height: bigint, index: number, tx: Tx, result: ResponseDeliverTx, hash: Bytes);
+    }
+    class Tx {
+        body: TxBody;
+        authInfo: AuthInfo;
+        signatures: Array<Bytes>;
+        constructor(body: TxBody, authInfo: AuthInfo, signatures: Array<Bytes>);
+    }
+    class TxBody {
+        messages: Array<Any>;
+        memo: string;
+        timeoutHeight: bigint;
+        extensionOptions: Array<Any>;
+        nonCriticalExtensionOptions: Array<Any>;
+        constructor(messages: Array<Any>, memo: string, timeoutHeight: bigint, extensionOptions: Array<Any>, nonCriticalExtensionOptions: Array<Any>);
+    }
+    class Any {
+        typeUrl: string;
+        value: Bytes;
+        constructor(typeUrl: string, value: Bytes);
+    }
+    class AuthInfo {
+        signerInfos: Array<SignerInfo>;
+        fee: Fee;
+        tip: Tip;
+        constructor(signerInfos: Array<SignerInfo>, fee: Fee, tip: Tip);
+    }
+    class SignerInfo {
+        publicKey: Any;
+        modeInfo: ModeInfo;
+        sequence: bigint;
+        constructor(publicKey: Any, modeInfo: ModeInfo, sequence: bigint);
+    }
+    class ModeInfo {
+        single: ModeInfoSingle;
+        multi: ModeInfoMulti;
+        constructor(single: ModeInfoSingle, multi: ModeInfoMulti);
+    }
+    class ModeInfoSingle {
+        mode: SignMode;
+        constructor(mode: SignMode);
+    }
+    enum SignMode {
+        SIGN_MODE_UNSPECIFIED = 0,
+        SIGN_MODE_DIRECT = 1,
+        SIGN_MODE_TEXTUAL = 2,
+        SIGN_MODE_LEGACY_AMINO_JSON = 127
+    }
+    class ModeInfoMulti {
+        bitarray: CompactBitArray;
+        modeInfos: Array<ModeInfo>;
+        constructor(bitarray: CompactBitArray, modeInfos: Array<ModeInfo>);
+    }
+    class CompactBitArray {
+        extraBitsStored: number;
+        elems: Bytes;
+        constructor(extraBitsStored: number, elems: Bytes);
+    }
+    class Fee {
+        amount: Array<Coin>;
+        gasLimit: bigint;
+        payer: string;
+        granter: string;
+        constructor(amount: Array<Coin>, gasLimit: bigint, payer: string, granter: string);
+    }
+    class Coin {
+        denom: string;
+        amount: string;
+        constructor(denom: string, amount: string);
+    }
+    class Tip {
+        amount: Array<Coin>;
+        tipper: string;
+        constructor(amount: Array<Coin>, tipper: string);
+    }
+    class ResponseDeliverTx {
+        code: number;
+        data: Bytes;
+        log: string;
+        info: string;
+        gasWanted: bigint;
+        gasUsed: bigint;
+        events: Array<Event>;
+        codespace: string;
+        constructor(code: number, data: Bytes, log: string, info: string, gasWanted: bigint, gasUsed: bigint, events: Array<Event>, codespace: string);
+    }
+    class ValidatorSetUpdates {
+        validatorUpdates: Array<Validator>;
+        constructor(validatorUpdates: Array<Validator>);
+    }
+}

package/src/subgraph/graph-ts-types/chain/ethereum.d.ts

@@ -0,0 +1,233 @@
+import '../common/eager-offset';
+import { Bytes, Wrapped } from '../common/collections';
+import { Address, BigInt } from '../common/numbers';
+/** Host Ethereum interface */
+export declare namespace ethereum {
+    function call(call: SmartContractCall): Array<Value> | null;
+    function getBalance(address: Address): BigInt;
+    function hasCode(address: Address): Wrapped<boolean>;
+    function encode(token: Value): Bytes | null;
+    function decode(types: string, data: Bytes): Value | null;
+}
+export declare namespace ethereum {
+    /** Type hint for Ethereum values. */
+    enum ValueKind {
+        ADDRESS = 0,
+        FIXED_BYTES = 1,
+        BYTES = 2,
+        INT = 3,
+        UINT = 4,
+        BOOL = 5,
+        STRING = 6,
+        FIXED_ARRAY = 7,
+        ARRAY = 8,
+        TUPLE = 9
+    }
+    /**
+     * Pointer type for Ethereum value data.
+     *
+     * Big enough to fit any pointer or native `this.data`.
+     */
+    type ValuePayload = bigint;
+    /**
+     * A dynamically typed value used when accessing Ethereum data.
+     */
+    class Value {
+        kind: ValueKind;
+        data: ValuePayload;
+        constructor(kind: ValueKind, data: ValuePayload);
+        lt(_: Value): boolean;
+        gt(_: Value): boolean;
+        toAddress(): Address;
+        toBoolean(): boolean;
+        toBytes(): Bytes;
+        toI32(): number;
+        toBigInt(): BigInt;
+        toString(): string;
+        toArray(): Array<Value>;
+        toTuple(): Tuple;
+        toMatrix(): Array<Array<Value>>;
+        toTupleArray<T extends Tuple>(): Array<T>;
+        toTupleMatrix<T extends Tuple>(): Array<Array<T>>;
+        toBooleanArray(): Array<boolean>;
+        toBytesArray(): Array<Bytes>;
+        toAddressArray(): Array<Address>;
+        toStringArray(): Array<string>;
+        toI32Array(): Array<number>;
+        toBigIntArray(): Array<BigInt>;
+        toBooleanMatrix(): Array<Array<boolean>>;
+        toBytesMatrix(): Array<Array<Bytes>>;
+        toAddressMatrix(): Array<Array<Address>>;
+        toStringMatrix(): Array<Array<string>>;
+        toI32Matrix(): Array<Array<number>>;
+        toBigIntMatrix(): Array<Array<BigInt>>;
+        static fromAddress(address: Address): Value;
+        static fromBoolean(b: boolean): Value;
+        static fromBytes(bytes: Bytes): Value;
+        static fromFixedBytes(bytes: Bytes): Value;
+        static fromI32(i: number): Value;
+        static fromSignedBigInt(i: BigInt): Value;
+        static fromUnsignedBigInt(i: BigInt): Value;
+        static fromString(s: string): Value;
+        static fromArray(values: Array<Value>): Value;
+        static fromFixedSizedArray(values: Array<Value>): Value;
+        static fromTuple(values: Tuple): Value;
+        static fromMatrix(values: Array<Array<Value>>): Value;
+        static fromTupleArray(values: Array<Tuple>): Value;
+        static fromTupleMatrix(values: Array<Array<Tuple>>): Value;
+        static fromBooleanArray(values: Array<boolean>): Value;
+        static fromBytesArray(values: Array<Bytes>): Value;
+        static fromFixedBytesArray(values: Array<Bytes>): Value;
+        static fromAddressArray(values: Array<Address>): Value;
+        static fromStringArray(values: Array<string>): Value;
+        static fromI32Array(values: Array<number>): Value;
+        static fromSignedBigIntArray(values: Array<BigInt>): Value;
+        static fromUnsignedBigIntArray(values: Array<BigInt>): Value;
+        static fromBooleanMatrix(values: Array<Array<boolean>>): Value;
+        static fromBytesMatrix(values: Array<Array<Bytes>>): Value;
+        static fromFixedBytesMatrix(values: Array<Array<Bytes>>): Value;
+        static fromAddressMatrix(values: Array<Array<Address>>): Value;
+        static fromStringMatrix(values: Array<Array<string>>): Value;
+        static fromI32Matrix(values: Array<Array<number>>): Value;
+        static fromSignedBigIntMatrix(values: Array<Array<BigInt>>): Value;
+        static fromUnsignedBigIntMatrix(values: Array<Array<BigInt>>): Value;
+    }
+    /**
+     * Common representation for Ethereum tuples / Solidity structs.
+     *
+     * This base class stores the tuple/struct values in an array. The Graph CLI
+     * code generation then creates subclasses that provide named getters to
+     * access the members by name.
+     */
+    class Tuple extends Array<Value> {
+    }
+    /**
+     * An Ethereum block.
+     */
+    class Block {
+        hash: Bytes;
+        parentHash: Bytes;
+        unclesHash: Bytes;
+        author: Address;
+        stateRoot: Bytes;
+        transactionsRoot: Bytes;
+        receiptsRoot: Bytes;
+        number: BigInt;
+        gasUsed: BigInt;
+        gasLimit: BigInt;
+        timestamp: BigInt;
+        difficulty: BigInt;
+        totalDifficulty: BigInt;
+        size: BigInt | null;
+        baseFeePerGas: BigInt | null;
+        constructor(hash: Bytes, parentHash: Bytes, unclesHash: Bytes, author: Address, stateRoot: Bytes, transactionsRoot: Bytes, receiptsRoot: Bytes, number: BigInt, gasUsed: BigInt, gasLimit: BigInt, timestamp: BigInt, difficulty: BigInt, totalDifficulty: BigInt, size: BigInt | null, baseFeePerGas: BigInt | null);
+    }
+    /**
+     * An Ethereum transaction.
+     */
+    class Transaction {
+        hash: Bytes;
+        index: BigInt;
+        from: Address;
+        to: Address | null;
+        value: BigInt;
+        gasLimit: BigInt;
+        gasPrice: BigInt;
+        input: Bytes;
+        nonce: BigInt;
+        constructor(hash: Bytes, index: BigInt, from: Address, to: Address | null, value: BigInt, gasLimit: BigInt, gasPrice: BigInt, input: Bytes, nonce: BigInt);
+    }
+    /**
+     * An Ethereum transaction receipt.
+     */
+    class TransactionReceipt {
+        transactionHash: Bytes;
+        transactionIndex: BigInt;
+        blockHash: Bytes;
+        blockNumber: BigInt;
+        cumulativeGasUsed: BigInt;
+        gasUsed: BigInt;
+        contractAddress: Address;
+        logs: Array<Log>;
+        status: BigInt;
+        root: Bytes;
+        logsBloom: Bytes;
+        constructor(transactionHash: Bytes, transactionIndex: BigInt, blockHash: Bytes, blockNumber: BigInt, cumulativeGasUsed: BigInt, gasUsed: BigInt, contractAddress: Address, logs: Array<Log>, status: BigInt, root: Bytes, logsBloom: Bytes);
+    }
+    /**
+     * An Ethereum event log.
+     */
+    class Log {
+        address: Address;
+        topics: Array<Bytes>;
+        data: Bytes;
+        blockHash: Bytes;
+        blockNumber: Bytes;
+        transactionHash: Bytes;
+        transactionIndex: BigInt;
+        logIndex: BigInt;
+        transactionLogIndex: BigInt;
+        logType: string;
+        removed: Wrapped<boolean> | null;
+        constructor(address: Address, topics: Array<Bytes>, data: Bytes, blockHash: Bytes, blockNumber: Bytes, transactionHash: Bytes, transactionIndex: BigInt, logIndex: BigInt, transactionLogIndex: BigInt, logType: string, removed: Wrapped<boolean> | null);
+    }
+    /**
+     * Common representation for Ethereum smart contract calls.
+     */
+    class Call {
+        to: Address;
+        from: Address;
+        block: Block;
+        transaction: Transaction;
+        inputValues: Array<EventParam>;
+        outputValues: Array<EventParam>;
+        constructor(to: Address, from: Address, block: Block, transaction: Transaction, inputValues: Array<EventParam>, outputValues: Array<EventParam>);
+    }
+    /**
+     * Common representation for Ethereum smart contract events.
+     */
+    class Event {
+        address: Address;
+        logIndex: BigInt;
+        transactionLogIndex: BigInt;
+        logType: string | null;
+        block: Block;
+        transaction: Transaction;
+        parameters: Array<EventParam>;
+        receipt: TransactionReceipt | null;
+        constructor(address: Address, logIndex: BigInt, transactionLogIndex: BigInt, logType: string | null, block: Block, transaction: Transaction, parameters: Array<EventParam>, receipt: TransactionReceipt | null);
+    }
+    /**
+     * A dynamically-typed Ethereum event parameter.
+     */
+    class EventParam {
+        name: string;
+        value: Value;
+        constructor(name: string, value: Value);
+    }
+    class SmartContractCall {
+        contractName: string;
+        contractAddress: Address;
+        functionName: string;
+        functionSignature: string;
+        functionParams: Array<Value>;
+        constructor(contractName: string, contractAddress: Address, functionName: string, functionSignature: string, functionParams: Array<Value>);
+    }
+    /**
+     * Low-level interaction with Ethereum smart contracts
+     */
+    class SmartContract {
+        _name: string;
+        _address: Address;
+        protected constructor(name: string, address: Address);
+        call(name: string, signature: string, params: Array<Value>): Array<Value>;
+        tryCall(name: string, signature: string, params: Array<Value>): CallResult<Array<Value>>;
+    }
+    class CallResult<T> {
+        private _value;
+        constructor();
+        static fromValue<T>(value: T): CallResult<T>;
+        get reverted(): boolean;
+        get value(): T;
+    }
+}