envio 3.6.0 → 3.6.1-subgraph

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

@@ -0,0 +1,253 @@
+import '../common/eager-offset';
+import { Bytes } from '../common/collections';
+import { BigInt } from '../common/numbers';
+export declare namespace near {
+    type CryptoHash = Bytes;
+    type Account = string;
+    type BlockHeight = bigint;
+    type Balance = BigInt;
+    type Gas = bigint;
+    type ShardId = bigint;
+    type NumBlocks = bigint;
+    type ProtocolVersion = number;
+    type Payload = bigint;
+    enum CurveKind {
+        ED25519 = 0,
+        SECP256K1 = 1
+    }
+    class Signature {
+        kind: CurveKind;
+        bytes: Bytes;
+        constructor(kind: CurveKind, bytes: Bytes);
+    }
+    class PublicKey {
+        kind: CurveKind;
+        bytes: Bytes;
+        constructor(kind: CurveKind, bytes: Bytes);
+    }
+    enum AccessKeyPermissionKind {
+        FUNCTION_CALL = 0,
+        FULL_ACCESS = 1
+    }
+    class FunctionCallPermission {
+        allowance: BigInt;
+        receiverId: string;
+        methodNames: Array<string>;
+        constructor(allowance: BigInt, receiverId: string, methodNames: Array<string>);
+    }
+    class FullAccessPermission {
+    }
+    class AccessKeyPermissionValue {
+        kind: AccessKeyPermissionKind;
+        data: Payload;
+        constructor(kind: AccessKeyPermissionKind, data: Payload);
+        toFunctionCall(): FunctionCallPermission;
+        toFullAccess(): FullAccessPermission;
+        static fromFunctionCall(input: FunctionCallPermission): AccessKeyPermissionValue;
+        static fromFullAccess(input: FullAccessPermission): AccessKeyPermissionValue;
+    }
+    class AccessKey {
+        nonce: bigint;
+        permission: AccessKeyPermissionValue;
+        constructor(nonce: bigint, permission: AccessKeyPermissionValue);
+    }
+    class DataReceiver {
+        dataId: CryptoHash;
+        receiverId: string;
+        constructor(dataId: CryptoHash, receiverId: string);
+    }
+    enum ActionKind {
+        CREATE_ACCOUNT = 0,
+        DEPLOY_CONTRACT = 1,
+        FUNCTION_CALL = 2,
+        TRANSFER = 3,
+        STAKE = 4,
+        ADD_KEY = 5,
+        DELETE_KEY = 6,
+        DELETE_ACCOUNT = 7
+    }
+    class CreateAccountAction {
+    }
+    class DeployContractAction {
+        codeHash: Bytes;
+        constructor(codeHash: Bytes);
+    }
+    class FunctionCallAction {
+        methodName: string;
+        args: Bytes;
+        gas: bigint;
+        deposit: BigInt;
+        constructor(methodName: string, args: Bytes, gas: bigint, deposit: BigInt);
+    }
+    class TransferAction {
+        deposit: BigInt;
+        constructor(deposit: BigInt);
+    }
+    class StakeAction {
+        stake: Balance;
+        publicKey: PublicKey;
+        constructor(stake: Balance, publicKey: PublicKey);
+    }
+    class AddKeyAction {
+        publicKey: PublicKey;
+        accessKey: AccessKey;
+        constructor(publicKey: PublicKey, accessKey: AccessKey);
+    }
+    class DeleteKeyAction {
+        publicKey: PublicKey;
+        constructor(publicKey: PublicKey);
+    }
+    class DeleteAccountAction {
+        beneficiaryId: Account;
+        constructor(beneficiaryId: Account);
+    }
+    class ActionValue {
+        kind: ActionKind;
+        data: Payload;
+        constructor(kind: ActionKind, data: Payload);
+        toCreateAccount(): CreateAccountAction;
+        toDeployContract(): DeployContractAction;
+        toFunctionCall(): FunctionCallAction;
+        toTransfer(): TransferAction;
+        toStake(): StakeAction;
+        toAddKey(): AddKeyAction;
+        toDeleteKey(): DeleteKeyAction;
+        toDeleteAccount(): DeleteAccountAction;
+        static fromCreateAccount(input: CreateAccountAction): ActionValue;
+        static fromDeployContract(input: DeployContractAction): ActionValue;
+        static fromFunctionCall(input: FunctionCallAction): ActionValue;
+        static fromTransfer(input: TransferAction): ActionValue;
+        static fromStake(input: StakeAction): ActionValue;
+        static fromAddKey(input: AddKeyAction): ActionValue;
+        static fromDeleteKey(input: DeleteKeyAction): ActionValue;
+        static fromDeleteAccount(input: DeleteAccountAction): ActionValue;
+    }
+    class ActionReceipt {
+        predecessorId: string;
+        receiverId: string;
+        id: CryptoHash;
+        signerId: string;
+        signerPublicKey: PublicKey;
+        gasPrice: BigInt;
+        outputDataReceivers: Array<DataReceiver>;
+        inputDataIds: Array<CryptoHash>;
+        actions: Array<ActionValue>;
+        constructor(predecessorId: string, receiverId: string, id: CryptoHash, signerId: string, signerPublicKey: PublicKey, gasPrice: BigInt, outputDataReceivers: Array<DataReceiver>, inputDataIds: Array<CryptoHash>, actions: Array<ActionValue>);
+    }
+    enum SuccessStatusKind {
+        VALUE = 0,
+        RECEIPT_ID = 1
+    }
+    class SuccessStatus {
+        kind: SuccessStatusKind;
+        data: Payload;
+        constructor(kind: SuccessStatusKind, data: Payload);
+        toValue(): Bytes;
+        toReceiptId(): CryptoHash;
+        static fromValue(input: Bytes): SuccessStatus;
+        static fromReceiptId(input: CryptoHash): SuccessStatus;
+    }
+    enum Direction {
+        LEFT = 0,
+        RIGHT = 1
+    }
+    class MerklePathItem {
+        hash: CryptoHash;
+        direction: Direction;
+        constructor(hash: CryptoHash, direction: Direction);
+        lt(_: MerklePathItem): boolean;
+        gt(_: MerklePathItem): boolean;
+        toString(): string;
+    }
+    class MerklePath extends Array<MerklePathItem> {
+    }
+    class ExecutionOutcome {
+        gasBurnt: bigint;
+        proof: MerklePath;
+        blockHash: CryptoHash;
+        id: CryptoHash;
+        logs: Array<string>;
+        receiptIds: Array<CryptoHash>;
+        tokensBurnt: BigInt;
+        executorId: string;
+        status: SuccessStatus;
+        constructor(gasBurnt: bigint, proof: MerklePath, blockHash: CryptoHash, id: CryptoHash, logs: Array<string>, receiptIds: Array<CryptoHash>, tokensBurnt: BigInt, executorId: string, status: SuccessStatus);
+    }
+    class SlashedValidator {
+        account: Account;
+        isDoubleSign: boolean;
+        constructor(account: Account, isDoubleSign: boolean);
+    }
+    class BlockHeader {
+        height: BlockHeight;
+        prevHeight: BlockHeight;
+        blockOrdinal: NumBlocks;
+        epochId: CryptoHash;
+        nextEpochId: CryptoHash;
+        chunksIncluded: bigint;
+        hash: CryptoHash;
+        prevHash: CryptoHash;
+        timestampNanosec: bigint;
+        prevStateRoot: CryptoHash;
+        chunkReceiptsRoot: CryptoHash;
+        chunkHeadersRoot: CryptoHash;
+        chunkTxRoot: CryptoHash;
+        outcomeRoot: CryptoHash;
+        challengesRoot: CryptoHash;
+        randomValue: CryptoHash;
+        validatorProposals: Array<ValidatorStake>;
+        chunkMask: Array<boolean>;
+        gasPrice: Balance;
+        totalSupply: Balance;
+        challengesResult: Array<SlashedValidator>;
+        lastFinalBlock: CryptoHash;
+        lastDsFinalBlock: CryptoHash;
+        nextBpHash: CryptoHash;
+        blockMerkleRoot: CryptoHash;
+        epochSyncDataHash: CryptoHash;
+        approvals: Array<Signature>;
+        signature: Signature;
+        latestProtocolVersion: ProtocolVersion;
+        constructor(height: BlockHeight, prevHeight: BlockHeight, // Always zero when version < V3
+        blockOrdinal: NumBlocks, // Always zero when version < V3
+        epochId: CryptoHash, nextEpochId: CryptoHash, chunksIncluded: bigint, hash: CryptoHash, prevHash: CryptoHash, timestampNanosec: bigint, prevStateRoot: CryptoHash, chunkReceiptsRoot: CryptoHash, chunkHeadersRoot: CryptoHash, chunkTxRoot: CryptoHash, outcomeRoot: CryptoHash, challengesRoot: CryptoHash, randomValue: CryptoHash, validatorProposals: Array<ValidatorStake>, chunkMask: Array<boolean>, gasPrice: Balance, totalSupply: Balance, challengesResult: Array<SlashedValidator>, lastFinalBlock: CryptoHash, lastDsFinalBlock: CryptoHash, nextBpHash: CryptoHash, blockMerkleRoot: CryptoHash, epochSyncDataHash: CryptoHash, // Always empty when version < V3
+        approvals: Array<Signature>, // Array<Option<Signature>>
+        signature: Signature, latestProtocolVersion: ProtocolVersion);
+    }
+    class ValidatorStake {
+        account: Account;
+        publicKey: PublicKey;
+        stake: Balance;
+        constructor(account: Account, publicKey: PublicKey, stake: Balance);
+    }
+    class ChunkHeader {
+        encodedLength: bigint;
+        gasUsed: Gas;
+        gasLimit: Gas;
+        shardId: ShardId;
+        heightCreated: BlockHeight;
+        heightIncluded: BlockHeight;
+        chunkHash: CryptoHash;
+        signature: Signature;
+        prevBlockHash: CryptoHash;
+        prevStateRoot: CryptoHash;
+        encodedMerkleRoot: CryptoHash;
+        balanceBurnt: Balance;
+        outgoingReceiptsRoot: CryptoHash;
+        txRoot: CryptoHash;
+        validatorProposals: Array<ValidatorStake>;
+        constructor(encodedLength: bigint, gasUsed: Gas, gasLimit: Gas, shardId: ShardId, heightCreated: BlockHeight, heightIncluded: BlockHeight, chunkHash: CryptoHash, signature: Signature, prevBlockHash: CryptoHash, prevStateRoot: CryptoHash, encodedMerkleRoot: CryptoHash, balanceBurnt: Balance, outgoingReceiptsRoot: CryptoHash, txRoot: CryptoHash, validatorProposals: Array<ValidatorStake>);
+    }
+    class Block {
+        author: Account;
+        header: BlockHeader;
+        chunks: Array<ChunkHeader>;
+        constructor(author: Account, header: BlockHeader, chunks: Array<ChunkHeader>);
+    }
+    class ReceiptWithOutcome {
+        outcome: ExecutionOutcome;
+        receipt: ActionReceipt;
+        block: Block;
+        constructor(outcome: ExecutionOutcome, receipt: ActionReceipt, block: Block);
+    }
+}

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

@@ -0,0 +1,32 @@
+import '../common/eager-offset';
+import { Bytes } from '../common/collections';
+import { BigInt } from '../common/numbers';
+export declare namespace starknet {
+    class Block {
+        number: BigInt;
+        hash: Bytes;
+        prevHash: Bytes;
+        timestamp: BigInt;
+        constructor(number: BigInt, hash: Bytes, prevHash: Bytes, timestamp: BigInt);
+    }
+    class Transaction {
+        type: TransactionType;
+        hash: Bytes;
+        constructor(type: TransactionType, hash: Bytes);
+    }
+    enum TransactionType {
+        DEPLOY = 0,
+        INVOKE_FUNCTION = 1,
+        DECLARE = 2,
+        L1_HANDLER = 3,
+        DEPLOY_ACCOUNT = 4
+    }
+    class Event {
+        fromAddr: Bytes;
+        keys: Array<Bytes>;
+        data: Array<Bytes>;
+        block: Block;
+        transaction: Transaction;
+        constructor(fromAddr: Bytes, keys: Array<Bytes>, data: Array<Bytes>, block: Block, transaction: Transaction);
+    }
+}

package/src/subgraph/graph-ts-types/common/collections.d.ts

@@ -0,0 +1,136 @@
+import { BigDecimal, BigInt } from './numbers';
+import { Value } from './value';
+/**
+ * Byte array
+ */
+export declare class ByteArray extends Uint8Array {
+    /**
+     * Returns bytes in little-endian order.
+     */
+    static fromI32(x: number): ByteArray;
+    /**
+     * Returns bytes in little-endian order.
+     */
+    static fromU32(x: number): ByteArray;
+    /**
+     * Returns bytes in little-endian order.
+     */
+    static fromI64(x: bigint): ByteArray;
+    /**
+     * Returns bytes in little-endian order.
+     */
+    static fromU64(x: bigint): ByteArray;
+    static empty(): ByteArray;
+    /**
+     * Convert the string `hex` which must consist of an even number of
+     * hexadecimal digits to a `ByteArray`. The string `hex` can optionally
+     * start with '0x'
+     */
+    static fromHexString(hex: string): ByteArray;
+    static fromUTF8(str: string): ByteArray;
+    static fromBigInt(bigInt: BigInt): ByteArray;
+    toHex(): string;
+    toHexString(): string;
+    toString(): string;
+    toBase58(): string;
+    /**
+     * Interprets the byte array as a little-endian U32.
+     * Throws in case of overflow.
+     */
+    toU32(): number;
+    /**
+     * Interprets the byte array as a little-endian I32.
+     * Throws in case of overflow.
+     */
+    toI32(): number;
+    /** Create a new `ByteArray` that consist of `this` directly followed by
+     * the bytes from `other` */
+    concat(other: ByteArray): ByteArray;
+    /** Create a new `ByteArray` that consists of `this` directly followed by
+     * the representation of `other` as bytes */
+    concatI32(other: number): ByteArray;
+    /**
+     * Interprets the byte array as a little-endian I64.
+     * Throws in case of overflow.
+     */
+    toI64(): bigint;
+    /**
+     * Interprets the byte array as a little-endian U64.
+     * Throws in case of overflow.
+     */
+    toU64(): bigint;
+    equals(other: ByteArray): boolean;
+    notEqual(other: ByteArray): boolean;
+}
+/** A dynamically-sized byte array. */
+export declare class Bytes extends ByteArray {
+    static fromByteArray(byteArray: ByteArray): Bytes;
+    static fromUint8Array(uint8Array: Uint8Array): Bytes;
+    /**
+     * Convert the string `hex` which must consist of an even number of
+     * hexadecimal digits to a `ByteArray`. The string `hex` can optionally
+     * start with '0x'
+     */
+    static fromHexString(str: string): Bytes;
+    static fromUTF8(str: string): Bytes;
+    static fromI32(i: number): Bytes;
+    static empty(): Bytes;
+    concat(other: Bytes): Bytes;
+    concatI32(other: number): Bytes;
+}
+/**
+ * TypedMap entry.
+ */
+export declare class TypedMapEntry<K, V> {
+    key: K;
+    value: V;
+    constructor(key: K, value: V);
+}
+/** Typed map */
+export declare class TypedMap<K, V> {
+    entries: Array<TypedMapEntry<K, V>>;
+    constructor();
+    set(key: K, value: V): void;
+    getEntry(key: K): TypedMapEntry<K, V> | null;
+    mustGetEntry(key: K): TypedMapEntry<K, V>;
+    get(key: K): V | null;
+    mustGet(key: K): V;
+    isSet(key: K): boolean;
+}
+/**
+ * Common representation for entity data, storing entity attributes
+ * as `string` keys and the attribute values as dynamically-typed
+ * `Value` objects.
+ */
+export declare class Entity extends TypedMap<string, Value> {
+    unset(key: string): void;
+    /** Assigns properties from sources to this Entity in right-to-left order */
+    merge(sources: Array<Entity>): Entity;
+    setString(key: string, value: string): void;
+    setI32(key: string, value: number): void;
+    setBigInt(key: string, value: BigInt): void;
+    setBytes(key: string, value: Bytes): void;
+    setBoolean(key: string, value: boolean): void;
+    setBigDecimal(key: string, value: BigDecimal): void;
+    getString(key: string): string;
+    getI32(key: string): number;
+    getBigInt(key: string): BigInt;
+    getBytes(key: string): Bytes;
+    getBoolean(key: string): boolean;
+    getBigDecimal(key: string): BigDecimal;
+}
+/**
+ * The result of an operation, with a corresponding value and error type.
+ */
+export declare class Result<V, E> {
+    _value: Wrapped<V> | null;
+    _error: Wrapped<E> | null;
+    get isOk(): boolean;
+    get isError(): boolean;
+    get value(): V;
+    get error(): E;
+}
+export declare class Wrapped<T> {
+    inner: T;
+    constructor(inner: T);
+}

package/src/subgraph/graph-ts-types/common/conversion.d.ts

@@ -0,0 +1,11 @@
+import './eager-offset';
+import { Bytes } from './collections';
+/** Host type conversion interface */
+export declare namespace typeConversion {
+    function bytesToString(bytes: Uint8Array): string;
+    function bytesToHex(bytes: Uint8Array): string;
+    function bigIntToString(bigInt: Uint8Array): string;
+    function bigIntToHex(bigInt: Uint8Array): string;
+    function stringToH160(s: string): Bytes;
+    function bytesToBase58(n: Uint8Array): string;
+}

package/src/subgraph/graph-ts-types/common/datasource.d.ts

@@ -0,0 +1,30 @@
+import './eager-offset';
+import { Entity } from './collections';
+import { Address } from './numbers';
+/** Host interface for managing data sources */
+export declare namespace dataSource {
+    function create(name: string, params: Array<string>): void;
+    function createWithContext(name: string, params: Array<string>, context: DataSourceContext): void;
+    function address(): Address;
+    function network(): string;
+    function context(): DataSourceContext;
+}
+export declare namespace dataSource {
+    function stringParam(): string;
+}
+/** Context for dynamic data sources */
+export declare class DataSourceContext extends Entity {
+}
+/**
+ * Base class for data source templates. Allows to dynamically create
+ * data sources from templates at runtime.
+ */
+export declare class DataSourceTemplate {
+    /**
+     * Dynamically creates a data source from the template with the
+     * given name, using the parameter strings to configure the new
+     * data source.
+     */
+    static create(name: string, params: Array<string>): void;
+    static createWithContext(name: string, params: Array<string>, context: DataSourceContext): void;
+}

package/src/subgraph/graph-ts-types/common/json.d.ts

@@ -0,0 +1,17 @@
+import './eager-offset';
+import { Bytes, Result } from './collections';
+import { BigInt } from './numbers';
+import { JSONValue } from './value';
+/** Host JSON interface */
+export declare namespace json {
+    function fromBytes(data: Bytes): JSONValue;
+    function try_fromBytes(data: Bytes): Result<JSONValue, boolean>;
+    function toI64(decimal: string): bigint;
+    function toU64(decimal: string): bigint;
+    function toF64(decimal: string): number;
+    function toBigInt(decimal: string): BigInt;
+}
+export declare namespace json {
+    function fromString(data: string): JSONValue;
+    function try_fromString(data: string): Result<JSONValue, boolean>;
+}

package/src/subgraph/graph-ts-types/common/numbers.d.ts

@@ -0,0 +1,120 @@
+import './eager-offset';
+import { ByteArray, Bytes } from './collections';
+/** Host interface for BigInt arithmetic */
+export declare namespace bigInt {
+    function plus(x: BigInt, y: BigInt): BigInt;
+    function minus(x: BigInt, y: BigInt): BigInt;
+    function times(x: BigInt, y: BigInt): BigInt;
+    function dividedBy(x: BigInt, y: BigInt): BigInt;
+    function dividedByDecimal(x: BigInt, y: BigDecimal): BigDecimal;
+    function mod(x: BigInt, y: BigInt): BigInt;
+    function pow(x: BigInt, exp: number): BigInt;
+    function fromString(s: string): BigInt;
+    function bitOr(x: BigInt, y: BigInt): BigInt;
+    function bitAnd(x: BigInt, y: BigInt): BigInt;
+    function leftShift(x: BigInt, bits: number): BigInt;
+    function rightShift(x: BigInt, bits: number): BigInt;
+}
+/** Host interface for BigDecimal */
+export declare namespace bigDecimal {
+    function plus(x: BigDecimal, y: BigDecimal): BigDecimal;
+    function minus(x: BigDecimal, y: BigDecimal): BigDecimal;
+    function times(x: BigDecimal, y: BigDecimal): BigDecimal;
+    function dividedBy(x: BigDecimal, y: BigDecimal): BigDecimal;
+    function equals(x: BigDecimal, y: BigDecimal): boolean;
+    function toString(bigDecimal: BigDecimal): string;
+    function fromString(s: string): BigDecimal;
+}
+export type Int8 = bigint;
+export type Timestamp = bigint;
+/** An Ethereum address (20 bytes). */
+export declare class Address extends Bytes {
+    static fromString(s: string): Address;
+    /** Convert `Bytes` that must be exactly 20 bytes long to an address.
+     * Passing in a value with fewer or more bytes will result in an error */
+    static fromBytes(b: Bytes): Address;
+    static zero(): Address;
+}
+/** An arbitrary size integer represented as an array of bytes. */
+export declare class BigInt extends Uint8Array {
+    static fromI32(x: number): BigInt;
+    static fromU32(x: number): BigInt;
+    static fromI64(x: bigint): BigInt;
+    static fromU64(x: bigint): BigInt;
+    static zero(): BigInt;
+    /**
+     * `bytes` assumed to be little-endian. If your input is big-endian, call `.reverse()` first.
+     */
+    static fromSignedBytes(bytes: Bytes): BigInt;
+    static fromByteArray(byteArray: ByteArray): BigInt;
+    /**
+     * `bytes` assumed to be little-endian. If your input is big-endian, call `.reverse()` first.
+     */
+    static fromUnsignedBytes(bytes: ByteArray): BigInt;
+    toHex(): string;
+    toHexString(): string;
+    toString(): string;
+    static fromString(s: string): BigInt;
+    toI32(): number;
+    toU32(): number;
+    toI64(): bigint;
+    toU64(): bigint;
+    toBigDecimal(): BigDecimal;
+    isZero(): boolean;
+    isI32(): boolean;
+    abs(): BigInt;
+    sqrt(): BigInt;
+    plus(other: BigInt): BigInt;
+    minus(other: BigInt): BigInt;
+    times(other: BigInt): BigInt;
+    div(other: BigInt): BigInt;
+    divDecimal(other: BigDecimal): BigDecimal;
+    mod(other: BigInt): BigInt;
+    equals(other: BigInt): boolean;
+    notEqual(other: BigInt): boolean;
+    lt(other: BigInt): boolean;
+    gt(other: BigInt): boolean;
+    le(other: BigInt): boolean;
+    ge(other: BigInt): boolean;
+    neg(): BigInt;
+    bitOr(other: BigInt): BigInt;
+    bitAnd(other: BigInt): BigInt;
+    leftShift(bits: number): BigInt;
+    rightShift(bits: number): BigInt;
+    pow(exp: number): BigInt;
+    /**
+     * Returns −1 if a < b, 1 if a > b, and 0 if A == B
+     */
+    static compare(a: BigInt, b: BigInt): number;
+}
+export declare class BigDecimal {
+    digits: BigInt;
+    exp: BigInt;
+    constructor(bigInt: BigInt);
+    static fromString(s: string): BigDecimal;
+    static zero(): BigDecimal;
+    toString(): string;
+    truncate(decimals: number): BigDecimal;
+    plus(other: BigDecimal): BigDecimal;
+    minus(other: BigDecimal): BigDecimal;
+    times(other: BigDecimal): BigDecimal;
+    div(other: BigDecimal): BigDecimal;
+    equals(other: BigDecimal): boolean;
+    notEqual(other: BigDecimal): boolean;
+    lt(other: BigDecimal): boolean;
+    gt(other: BigDecimal): boolean;
+    le(other: BigDecimal): boolean;
+    ge(other: BigDecimal): boolean;
+    neg(): BigDecimal;
+    /**
+     * Returns −1 if a < b, 1 if a > b, and 0 if A == B
+     */
+    static compare(a: BigDecimal, b: BigDecimal): number;
+}
+/** A type representing Starknet's field element type. */
+export declare class Felt extends Bytes {
+    /**
+     * Modifies and transforms the object IN-PLACE into `BigInt`.
+     */
+    intoBigInt(): BigInt;
+}