envio 3.6.0 → 3.6.1-subgraph

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

@@ -0,0 +1,120 @@
+import './eager-offset';
+import { Bytes, TypedMap } from './collections';
+import { Address, BigDecimal, BigInt } from './numbers';
+/**
+ * Enum for supported value types.
+ */
+export declare enum ValueKind {
+    STRING = 0,
+    INT = 1,
+    BIGDECIMAL = 2,
+    BOOL = 3,
+    ARRAY = 4,
+    NULL = 5,
+    BYTES = 6,
+    BIGINT = 7,
+    INT8 = 8,
+    TIMESTAMP = 9
+}
+/**
+ * Pointer type for Value data.
+ *
+ * Big enough to fit any pointer or native `this.data`.
+ */
+export type ValuePayload = bigint;
+/**
+ * A dynamically typed value.
+ */
+export declare class Value {
+    kind: ValueKind;
+    data: ValuePayload;
+    constructor(kind: ValueKind, data: ValuePayload);
+    toAddress(): Address;
+    toBoolean(): boolean;
+    toBytes(): Bytes;
+    toI32(): number;
+    toI64(): bigint;
+    toTimestamp(): bigint;
+    toString(): string;
+    toBigInt(): BigInt;
+    toBigDecimal(): BigDecimal;
+    toArray(): Array<Value>;
+    toMatrix(): Array<Array<Value>>;
+    toBooleanArray(): Array<boolean>;
+    toBytesArray(): Array<Bytes>;
+    toStringArray(): Array<string>;
+    toI32Array(): Array<number>;
+    toI64Array(): Array<bigint>;
+    toTimestampArray(): Array<bigint>;
+    toBigIntArray(): Array<BigInt>;
+    toBigDecimalArray(): Array<BigDecimal>;
+    toBooleanMatrix(): Array<Array<boolean>>;
+    toBytesMatrix(): Array<Array<Bytes>>;
+    toAddressMatrix(): Array<Array<Address>>;
+    toStringMatrix(): Array<Array<string>>;
+    toI32Matrix(): Array<Array<number>>;
+    toI64Matrix(): Array<Array<bigint>>;
+    toBigIntMatrix(): Array<Array<BigInt>>;
+    /** Return a string that indicates the kind of value `this` contains for
+     * logging and error messages */
+    displayKind(): string;
+    /** Return a string representation of the value of `this` for logging and
+     * error messages */
+    displayData(): string;
+    static fromBooleanArray(input: Array<boolean>): Value;
+    static fromBytesArray(input: Array<Bytes>): Value;
+    static fromI32Array(input: Array<number>): Value;
+    static fromI64Array(input: Array<bigint>): Value;
+    static fromBigIntArray(input: Array<BigInt>): Value;
+    static fromBigDecimalArray(input: Array<BigDecimal>): Value;
+    static fromStringArray(input: Array<string>): Value;
+    static fromAddressArray(input: Array<Address>): Value;
+    static fromArray(input: Array<Value>): Value;
+    static fromBigInt(n: BigInt): Value;
+    static fromBoolean(b: boolean): Value;
+    static fromBytes(bytes: Bytes): Value;
+    static fromNull(): Value;
+    static fromI32(n: number): Value;
+    static fromI64(n: bigint): Value;
+    static fromTimestamp(n: bigint): Value;
+    static fromString(s: string): Value;
+    static fromAddress(s: Address): Value;
+    static fromBigDecimal(n: BigDecimal): Value;
+    static fromMatrix(values: Array<Array<Value>>): Value;
+    static fromBooleanMatrix(values: Array<Array<boolean>>): Value;
+    static fromBytesMatrix(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 fromI64Matrix(values: Array<Array<bigint>>): Value;
+    static fromTimestampMatrix(values: Array<Array<bigint>>): Value;
+    static fromBigIntMatrix(values: Array<Array<BigInt>>): Value;
+}
+/** Type hint for JSON values. */
+export declare enum JSONValueKind {
+    NULL = 0,
+    BOOL = 1,
+    NUMBER = 2,
+    STRING = 3,
+    ARRAY = 4,
+    OBJECT = 5
+}
+/**
+ * Pointer type for JSONValue data.
+ *
+ * Big enough to fit any pointer or native `this.data`.
+ */
+export type JSONValuePayload = bigint;
+export declare class JSONValue {
+    kind: JSONValueKind;
+    data: JSONValuePayload;
+    isNull(): boolean;
+    toBool(): boolean;
+    toI64(): bigint;
+    toU64(): bigint;
+    toF64(): number;
+    toBigInt(): BigInt;
+    toString(): string;
+    toArray(): Array<JSONValue>;
+    toObject(): TypedMap<string, JSONValue>;
+}

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

@@ -0,0 +1,90 @@
+import './eager-offset';
+import { Bytes, Result, TypedMap } from './collections';
+import { BigInt } from './numbers';
+/**
+ * Host YAML interface.
+ */
+export declare namespace yaml {
+    /**
+     * Parses a YAML document from UTF-8 encoded bytes.
+     * Aborts mapping execution if the bytes cannot be parsed.
+     */
+    function fromBytes(data: Bytes): YAMLValue;
+    /**
+     * Parses a YAML document from UTF-8 encoded bytes.
+     * Returns `Result.error == true` if the bytes cannot be parsed.
+     */
+    function try_fromBytes(data: Bytes): Result<YAMLValue, boolean>;
+}
+export declare namespace yaml {
+    /**
+     * Parses a YAML document from a UTF-8 encoded string.
+     * Aborts mapping execution if the string cannot be parsed.
+     */
+    function fromString(data: string): YAMLValue;
+    /**
+     * Parses a YAML document from a UTF-8 encoded string.
+     * Returns `Result.error == true` if the string cannot be parsed.
+     */
+    function try_fromString(data: string): Result<YAMLValue, boolean>;
+}
+/**
+ * All possible YAML value types.
+ */
+export declare enum YAMLValueKind {
+    NULL = 0,
+    BOOL = 1,
+    NUMBER = 2,
+    STRING = 3,
+    ARRAY = 4,
+    OBJECT = 5,
+    TAGGED = 6
+}
+/**
+ * Pointer type for `YAMLValue` data.
+ *
+ * Big enough to fit any pointer or native `YAMLValue.data`.
+ */
+export type YAMLValuePayload = bigint;
+export declare class YAMLValue {
+    kind: YAMLValueKind;
+    data: YAMLValuePayload;
+    constructor(kind: YAMLValueKind, data: YAMLValuePayload);
+    static newNull(): YAMLValue;
+    static newBool(data: boolean): YAMLValue;
+    static newI64(data: bigint): YAMLValue;
+    static newU64(data: bigint): YAMLValue;
+    static newF64(data: number): YAMLValue;
+    static newBigInt(data: BigInt): YAMLValue;
+    static newString(data: string): YAMLValue;
+    static newArray(data: Array<YAMLValue>): YAMLValue;
+    static newObject(data: TypedMap<YAMLValue, YAMLValue>): YAMLValue;
+    static newTagged(tag: string, value: YAMLValue): YAMLValue;
+    isNull(): boolean;
+    isBool(): boolean;
+    isNumber(): boolean;
+    isString(): boolean;
+    isArray(): boolean;
+    isObject(): boolean;
+    isTagged(): boolean;
+    toBool(): boolean;
+    toNumber(): string;
+    toI64(): bigint;
+    toU64(): bigint;
+    toF64(): number;
+    toBigInt(): BigInt;
+    toString(): string;
+    toArray(): Array<YAMLValue>;
+    toObject(): TypedMap<YAMLValue, YAMLValue>;
+    toTagged(): YAMLTaggedValue;
+    static eq(a: YAMLValue, b: YAMLValue): boolean;
+    static ne(a: YAMLValue | null, b: YAMLValue | null): boolean;
+    get(index: string): YAMLValue;
+}
+export declare class YAMLTaggedValue {
+    tag: string;
+    value: YAMLValue;
+    constructor(tag: string, value: YAMLValue);
+    static eq(a: YAMLTaggedValue, b: YAMLTaggedValue): boolean;
+    static ne(a: YAMLTaggedValue | null, b: YAMLTaggedValue | null): boolean;
+}

package/src/subgraph/graph-ts-types/global/global.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Contains type IDs and their discriminants for every blockchain supported by Graph-Node.
+ *
+ * Each variant corresponds to the unique ID of an AssemblyScript concrete class used by
+ * Graph-Node's runtime.
+ *
+ * # Rules for updating this enum
+ *
+ * 1. The discriminants must have the same value as their counterparts in `IndexForAscTypeId` enum
+ *    from `graph-node`'s `graph::runtime` module. If not, the runtime will fail to determine the
+ *    correct class during allocation.
+ * 2. Each supported blockchain has a reserved space of 1,000 * contiguous variants.
+ * 3. Once defined, items and their discriminants cannot be changed, as this would break running
+ *    subgraphs compiled in previous versions of this representation.
+ */
+export declare enum TypeId {
+    String = 0,
+    ArrayBuffer = 1,
+    Int8Array = 2,
+    Int16Array = 3,
+    Int32Array = 4,
+    Int64Array = 5,
+    Uint8Array = 6,
+    Uint16Array = 7,
+    Uint32Array = 8,
+    Uint64Array = 9,
+    Float32Array = 10,
+    Float64Array = 11,
+    BigDecimal = 12,
+    ArrayBool = 13,
+    ArrayUint8Array = 14,
+    ArrayEthereumValue = 15,
+    ArrayStoreValue = 16,
+    ArrayJsonValue = 17,
+    ArrayString = 18,
+    ArrayEventParam = 19,
+    ArrayTypedMapEntryStringJsonValue = 20,
+    ArrayTypedMapEntryStringStoreValue = 21,
+    SmartContractCall = 22,
+    EventParam = 23,
+    EthereumTransaction = 24,
+    EthereumBlock = 25,
+    EthereumCall = 26,
+    WrappedTypedMapStringJsonValue = 27,
+    WrappedBool = 28,
+    WrappedJsonValue = 29,
+    EthereumValue = 30,
+    StoreValue = 31,
+    JsonValue = 32,
+    EthereumEvent = 33,
+    TypedMapEntryStringStoreValue = 34,
+    TypedMapEntryStringJsonValue = 35,
+    TypedMapStringStoreValue = 36,
+    TypedMapStringJsonValue = 37,
+    TypedMapStringTypedMapStringJsonValue = 38,
+    ResultTypedMapStringJsonValueBool = 39,
+    ResultJsonValueBool = 40,
+    ArrayU8 = 41,
+    ArrayU16 = 42,
+    ArrayU32 = 43,
+    ArrayU64 = 44,
+    ArrayI8 = 45,
+    ArrayI16 = 46,
+    ArrayI32 = 47,
+    ArrayI64 = 48,
+    ArrayF32 = 49,
+    ArrayF64 = 50,
+    ArrayBigDecimal = 51,
+    NearArrayDataReceiver = 52,
+    NearArrayCryptoHash = 53,
+    NearArrayActionValue = 54,
+    NearMerklePath = 55,// or NearArrayMerklePathItem
+    NearArrayValidatorStake = 56,
+    NearArraySlashedValidator = 57,
+    NearArraySignature = 58,
+    NearArrayChunkHeader = 59,
+    NearAccessKeyPermissionValue = 60,
+    NearActionValue = 61,
+    NearDirection = 62,// not used in graph-node anymore. Can be ignored.
+    NearPublicKey = 63,
+    NearSignature = 64,
+    NearFunctionCallPermission = 65,
+    NearFullAccessPermission = 66,
+    NearAccessKey = 67,
+    NearDataReceiver = 68,
+    NearCreateAccountAction = 69,
+    NearDeployContractAction = 70,
+    NearFunctionCallAction = 71,
+    NearTransferAction = 72,
+    NearStakeAction = 73,
+    NearAddKeyAction = 74,
+    NearDeleteKeyAction = 75,
+    NearDeleteAccountAction = 76,
+    NearActionReceipt = 77,
+    NearSuccessStatus = 78,
+    NearMerklePathItem = 79,
+    NearExecutionOutcome = 80,
+    NearSlashedValidator = 81,
+    NearBlockHeader = 82,
+    NearValidatorStake = 83,
+    NearChunkHeader = 84,
+    NearBlock = 85,
+    NearReceiptWithOutcome = 86,
+    TransactionReceipt = 1000,
+    Log = 1001,
+    ArrayH256 = 1002,
+    ArrayLog = 1003,
+    CosmosAny = 1500,
+    CosmosAnyArray = 1501,
+    CosmosBytesArray = 1502,
+    CosmosCoinArray = 1503,
+    CosmosCommitSigArray = 1504,
+    CosmosEventArray = 1505,
+    CosmosEventAttributeArray = 1506,
+    CosmosEvidenceArray = 1507,
+    CosmosModeInfoArray = 1508,
+    CosmosSignerInfoArray = 1509,
+    CosmosTxResultArray = 1510,
+    CosmosValidatorArray = 1511,
+    CosmosValidatorUpdateArray = 1512,
+    CosmosAuthInfo = 1513,
+    CosmosBlock = 1514,
+    CosmosBlockId = 1515,
+    CosmosBlockIdFlagEnum = 1516,
+    CosmosBlockParams = 1517,
+    CosmosCoin = 1518,
+    CosmosCommit = 1519,
+    CosmosCommitSig = 1520,
+    CosmosCompactBitArray = 1521,
+    CosmosConsensus = 1522,
+    CosmosConsensusParams = 1523,
+    CosmosDuplicateVoteEvidence = 1524,
+    CosmosDuration = 1525,
+    CosmosEvent = 1526,
+    CosmosEventAttribute = 1527,
+    CosmosEventData = 1528,
+    CosmosEventVote = 1529,
+    CosmosEvidence = 1530,
+    CosmosEvidenceList = 1531,
+    CosmosEvidenceParams = 1532,
+    CosmosFee = 1533,
+    CosmosHeader = 1534,
+    CosmosHeaderOnlyBlock = 1535,
+    CosmosLightBlock = 1536,
+    CosmosLightClientAttackEvidence = 1537,
+    CosmosModeInfo = 1538,
+    CosmosModeInfoMulti = 1539,
+    CosmosModeInfoSingle = 1540,
+    CosmosPartSetHeader = 1541,
+    CosmosPublicKey = 1542,
+    CosmosResponseBeginBlock = 1543,
+    CosmosResponseDeliverTx = 1544,
+    CosmosResponseEndBlock = 1545,
+    CosmosSignModeEnum = 1546,
+    CosmosSignedHeader = 1547,
+    CosmosSignedMsgTypeEnum = 1548,
+    CosmosSignerInfo = 1549,
+    CosmosTimestamp = 1550,
+    CosmosTip = 1551,
+    CosmosTransactionData = 1552,
+    CosmosTx = 1553,
+    CosmosTxBody = 1554,
+    CosmosTxResult = 1555,
+    CosmosValidator = 1556,
+    CosmosValidatorParams = 1557,
+    CosmosValidatorSet = 1558,
+    CosmosValidatorSetUpdates = 1559,
+    CosmosValidatorUpdate = 1560,
+    CosmosVersionParams = 1561,
+    CosmosMessageData = 1562,
+    CosmosTransactionContext = 1563,
+    ArweaveBlock = 2500,
+    ArweaveProofOfAccess = 2501,
+    ArweaveTag = 2502,
+    ArweaveTagArray = 2503,
+    ArweaveTransaction = 2504,
+    ArweaveTransactionArray = 2505,
+    ArweaveTransactionWithBlockPtr = 2506,
+    StarknetBlock = 3500,
+    StarknetTransaction = 3501,
+    StarknetTransactionTypeEnum = 3502,
+    StarknetEvent = 3503,
+    StarknetArrayBytes = 3504,
+    YamlValue = 5500,
+    YamlTaggedValue = 5501,
+    YamlTypedMapEntryValueValue = 5502,
+    YamlTypedMapValueValue = 5503,
+    YamlArrayValue = 5504,
+    YamlArrayTypedMapEntryValueValue = 5505,
+    YamlWrappedValue = 5506,
+    YamlResultValueBool = 5507
+}
+export declare function id_of_type(typeId: TypeId): number;
+export declare function allocate(size: number): number;

package/src/subgraph/graph-ts-types/helper-functions.d.ts

@@ -0,0 +1,22 @@
+import { ByteArray } from './index';
+/**
+ * Takes 2 ByteArrays and concatenates them
+ * @param a - 1st ByteArray
+ * @param b - 2nd ByteArray
+ * @returns A concatenated ByteArray
+ */
+export declare function concat(a: ByteArray, b: ByteArray): ByteArray;
+/**
+ * Parses a CSV string into an array of strings.
+ * @param csv CSV string.
+ * @returns Array of strings.
+ */
+export declare function parseCSV(csv: string): Array<string>;
+/**
+ * Adds 0x1220 to the front of a ByteArray. This can be used when an IPFS hash is stored in an Ethereum Bytes32 type.
+ * The IPFS hash will fit in a Bytes32 when 0x1220 is removed. Since 0x1220 is currently in front of every single IPFS
+ * hash, this works. But it is possible in the future that IPFS will update their spec.
+ * @param a - The ByteArray without 0x1220 prefixed
+ * @returns - The ByteArray with 0x1220 prefixed
+ */
+export declare function addQm(a: ByteArray): ByteArray;

package/src/subgraph/graph-ts-types/index.d.ts

@@ -0,0 +1,102 @@
+import { ByteArray, Bytes, Entity } from './common/collections';
+import { Value } from './common/value';
+export * from './chain/arweave';
+export * from './chain/ethereum';
+export * from './chain/near';
+export * from './chain/cosmos';
+export * from './chain/starknet';
+export * from './common/collections';
+export * from './common/conversion';
+export * from './common/datasource';
+export * from './common/json';
+export * from './common/numbers';
+export * from './common/value';
+export * from './common/yaml';
+/**
+ * Host store interface.
+ */
+export declare namespace store {
+    function get(entity: string, id: string): Entity | null;
+    /** If the entity was not created in the block, this function will return null. */
+    function get_in_block(entity: string, id: string): Entity | null;
+    function loadRelated(entity: string, id: string, field: string): Array<Entity>;
+    function set(entity: string, id: string, data: Entity): void;
+    function remove(entity: string, id: string): void;
+}
+/** Host IPFS interface */
+export declare namespace ipfs {
+    function cat(hash: string): Bytes | null;
+    function map(hash: string, callback: string, userData: Value, flags: string[]): void;
+}
+export declare namespace ipfs {
+    function mapJSON(hash: string, callback: string, userData: Value): void;
+}
+/** Host crypto utilities interface */
+export declare namespace crypto {
+    function keccak256(input: ByteArray): ByteArray;
+}
+/**
+ * Special function for ENS name lookups, not meant for general purpose use.
+ * This function will only be useful if the graph-node instance has additional
+ * data loaded **
+ */
+export declare namespace ens {
+    function nameByHash(hash: string): string | null;
+}
+export declare namespace log {
+    function log(level: Level, msg: string): void;
+}
+export declare namespace log {
+    enum Level {
+        CRITICAL = 0,
+        ERROR = 1,
+        WARNING = 2,
+        INFO = 3,
+        DEBUG = 4
+    }
+    /**
+     * Logs a critical message that terminates the subgraph.
+     *
+     * @param msg Format string a la "Value = {}, other = {}".
+     * @param args Format string arguments.
+     */
+    function critical(msg: string, args: Array<string>): void;
+    /**
+     * Logs an error message.
+     *
+     * @param msg Format string a la "Value = {}, other = {}".
+     * @param args Format string arguments.
+     */
+    function error(msg: string, args: Array<string>): void;
+    /** Logs a warning message.
+     *
+     * @param msg Format string a la "Value = {}, other = {}".
+     * @param args Format string arguments.
+     */
+    function warning(msg: string, args: Array<string>): void;
+    /** Logs an info message.
+     *
+     * @param msg Format string a la "Value = {}, other = {}".
+     * @param args Format string arguments.
+     */
+    function info(msg: string, args: Array<string>): void;
+    /** Logs a debug message.
+     *
+     * @param msg Format string a la "Value = {}, other = {}".
+     * @param args Format string arguments.
+     */
+    function debug(msg: string, args: Array<string>): void;
+}
+/**
+ * Helper functions for Ethereum.
+ */
+export declare namespace EthereumUtils {
+    /**
+     * Returns the contract address that would result from the given CREATE2 call.
+     * @param from The Ethereum address of the account that is initiating the contract creation.
+     * @param salt A 32-byte value that is used to create a deterministic address for the contract. This can be any arbitrary value, but it should be unique to the contract being created.
+     * @param initCodeHash he compiled code that will be executed when the contract is created. This should be a hex-encoded string that represents the compiled bytecode.
+     * @returns Address of the contract that would be created.
+     */
+    function getCreate2Address(from: Bytes, salt: Bytes, initCodeHash: Bytes): Bytes;
+}