@graphprotocol/graph-cli 0.23.0 → 0.23.1

package/README.md

@@ -53,6 +53,89 @@ The Graph CLI can be used with a local or self-hosted [Graph Node](https://githu
 
 If you are ready to dive into the details of building a subgraph from scratch, there is a [detailed walkthrough](https://thegraph.com/docs/define-a-subgraph) for that as well, along with API documentation for the [AssemblyScript API](https://thegraph.com/docs/assemblyscript-api).
 
+## Release process
+
+The steps to create a new version of the `graph-cli` are:
+
+1. Decide which version number you'll be rolling out. You can check the differences between the current `master` branch and the latest release.
+2. Create a PR with the commit generated by `npm version <VERSION> [<PREID>]`.
+3. Once that's approved and merged to `master`, you can publish it to `npm` and push the git tags as well.
+4. Last but not least, create a Github Release refering to the pushed git tag, linking to the PRs involved.
+
+Helpful links:
+
+- [Semver official docs](https://semver.org/)
+- [`npm version` docs](https://docs.npmjs.com/cli/v7/commands/npm-version)
+- [`npm publish` docs](https://docs.npmjs.com/cli/v7/commands/npm-publish)
+- [`npm unpublish` docs](https://docs.npmjs.com/cli/v7/commands/npm-unpublish)
+- [`npm deprecate` docs](https://docs.npmjs.com/cli/v7/commands/npm-deprecate)
+
+### Stable release example
+
+Current version: `0.34.9`.
+Desired release: `0.35.0`.
+
+To create the PR:
+```
+git checkout -b <BRANCH>
+
+npm version minor
+
+git push --set-upstream <REMOTE> <BRANCH>
+```
+
+Once that's approved and merged, you can update your local `master` and:
+
+```
+npm publish
+
+npm push --tags
+```
+
+### Alpha release example
+
+Current version: `0.29.2`.
+Desired release: `0.30.0-alpha.0`.
+
+To create the PR:
+```
+git checkout -b <BRANCH>
+
+npm version preminor --preid alpha
+
+git push --set-upstream <REMOTE> <BRANCH>
+```
+
+Once that's approved and merged, you can update your local `master` and:
+
+```
+npm publish --tag alpha
+
+npm push --tags
+```
+
+### Alpha pre-release example
+
+Current version: `0.30.0-alpha.0`.
+Desired release: `0.30.0-alpha.1`.
+
+To create the PR:
+```
+git checkout -b <BRANCH>
+
+npm version prerelease --preid alpha
+
+git push --set-upstream <REMOTE> <BRANCH>
+```
+
+Once that's approved and merged, you can update your local `master` and:
+
+```
+npm publish --tag alpha
+
+npm push --tags
+```
+
 ## License
 
 Copyright &copy; 2018-2019 Graph Protocol, Inc. and contributors.

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/.travis.yml

@@ -3,3 +3,7 @@ node_js:
   - "12"
   - "14"
   - "16"
+script:
+  - yarn build
+  - yarn lint
+  - yarn test

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/chain/ethereum.ts

@@ -35,10 +35,7 @@ export namespace ethereum {
    * A dynamically typed value used when accessing Ethereum data.
    */
   export class Value {
-    constructor(
-      public kind: ValueKind,
-      public data: ValuePayload,
-    ) {}
+    constructor(public kind: ValueKind, public data: ValuePayload) {}
 
     @operator('<')
     lt(other: Value): boolean {
@@ -113,7 +110,7 @@ export namespace ethereum {
       let valueArray = this.toArray()
       let out = new Array<T>(valueArray.length)
       for (let i: i32 = 0; i < valueArray.length; i++) {
-        out[i] = <T>valueArray[i].toTuple()
+        out[i] = changetype<T>(valueArray[i].toTuple())
       }
       return out
     }
@@ -341,7 +338,7 @@ export namespace ethereum {
       public timestamp: BigInt,
       public difficulty: BigInt,
       public totalDifficulty: BigInt,
-      public size: BigInt | null
+      public size: BigInt | null,
     ) {}
   }
 
@@ -349,7 +346,7 @@ export namespace ethereum {
    * An Ethereum transaction.
    */
   export class Transaction {
-    constructor (
+    constructor(
       public hash: Bytes,
       public index: BigInt,
       public from: Address,
@@ -357,7 +354,7 @@ export namespace ethereum {
       public value: BigInt,
       public gasLimit: BigInt,
       public gasPrice: BigInt,
-      public input: Bytes
+      public input: Bytes,
     ) {}
   }
 
@@ -365,13 +362,13 @@ export namespace ethereum {
    * Common representation for Ethereum smart contract calls.
    */
   export class Call {
-    constructor (
+    constructor(
       public to: Address,
       public from: Address,
       public block: Block,
       public transaction: Transaction,
       public inputValues: Array<EventParam>,
-      public outputValues: Array<EventParam>
+      public outputValues: Array<EventParam>,
     ) {}
   }
 
@@ -379,14 +376,14 @@ export namespace ethereum {
    * Common representation for Ethereum smart contract events.
    */
   export class Event {
-    constructor (
+    constructor(
       public address: Address,
       public logIndex: BigInt,
       public transactionLogIndex: BigInt,
       public logType: string | null,
       public block: Block,
       public transaction: Transaction,
-      public parameters: Array<EventParam>
+      public parameters: Array<EventParam>,
     ) {}
   }
 
@@ -394,10 +391,7 @@ export namespace ethereum {
    * A dynamically-typed Ethereum event parameter.
    */
   export class EventParam {
-    constructor (
-      public name: string,
-      public value: Value
-    ) {}
+    constructor(public name: string, public value: Value) {}
   }
 
   export class SmartContractCall {

package/examples/basic-event-handlers/node_modules/@graphprotocol/graph-ts/chain/near.ts

@@ -0,0 +1,402 @@
+import '../common/eager_offset'
+import { Bytes } from '../common/collections'
+import { BigInt } from '../common/numbers'
+
+// Most types from this namespace are direct mappings or adaptations from:
+// https://github.com/streamingfast/proto-near/blob/develop/sf/near/codec/v1/codec.proto
+export namespace near {
+  export type CryptoHash = Bytes
+
+  export type Account = string
+
+  export type BlockHeight = u64
+
+  export type Balance = BigInt
+
+  export type Gas = u64
+
+  export type ShardId = u64
+
+  export type NumBlocks = u64
+
+  export type ProtocolVersion = u32
+
+  export type Payload = u64
+
+  export enum CurveKind {
+    ED25519 = 0,
+    SECP256K1 = 1,
+  }
+
+  export class Signature {
+    constructor(public kind: CurveKind, public bytes: Bytes) {}
+  }
+
+  export class PublicKey {
+    constructor(public kind: CurveKind, public bytes: Bytes) {}
+  }
+
+  export enum AccessKeyPermissionKind {
+    FUNCTION_CALL = 0,
+    FULL_ACCESS = 1,
+  }
+
+  export class FunctionCallPermission {
+    constructor(
+      public allowance: BigInt,
+      public receiverId: string,
+      public methodNames: Array<string>,
+    ) {}
+  }
+
+  export class FullAccessPermission {}
+
+  export class AccessKeyPermissionValue {
+    constructor(public kind: AccessKeyPermissionKind, public data: Payload) {}
+
+    toFunctionCall(): FunctionCallPermission {
+      assert(
+        this.kind == AccessKeyPermissionKind.FUNCTION_CALL,
+        "AccessKeyPermissionValue is not a 'FunctionCall'.",
+      )
+      return changetype<FunctionCallPermission>(this.data as u32)
+    }
+
+    toFullAccess(): FullAccessPermission {
+      assert(
+        this.kind == AccessKeyPermissionKind.FULL_ACCESS,
+        "AccessKeyPermissionValue is not a 'FullAccess'.",
+      )
+      return changetype<FullAccessPermission>(this.data as u32)
+    }
+
+    static fromFunctionCall(input: FunctionCallPermission): AccessKeyPermissionValue {
+      return new AccessKeyPermissionValue(
+        AccessKeyPermissionKind.FUNCTION_CALL,
+        changetype<u32>(input),
+      )
+    }
+
+    static fromFullAccess(input: FullAccessPermission): AccessKeyPermissionValue {
+      return new AccessKeyPermissionValue(
+        AccessKeyPermissionKind.FULL_ACCESS,
+        changetype<u32>(input),
+      )
+    }
+  }
+
+  export class AccessKey {
+    constructor(public nonce: u64, public permission: AccessKeyPermissionValue) {}
+  }
+
+  export class DataReceiver {
+    constructor(public dataId: CryptoHash, public receiverId: string) {}
+  }
+
+  export enum ActionKind {
+    CREATE_ACCOUNT = 0,
+    DEPLOY_CONTRACT = 1,
+    FUNCTION_CALL = 2,
+    TRANSFER = 3,
+    STAKE = 4,
+    ADD_KEY = 5,
+    DELETE_KEY = 6,
+    DELETE_ACCOUNT = 7,
+  }
+
+  export class CreateAccountAction {}
+
+  export class DeployContractAction {
+    constructor(public codeHash: Bytes) {}
+  }
+
+  export class FunctionCallAction {
+    constructor(
+      public methodName: string,
+      public args: Bytes,
+      public gas: u64,
+      public deposit: BigInt,
+    ) {}
+  }
+
+  export class TransferAction {
+    constructor(public deposit: BigInt) {}
+  }
+
+  export class StakeAction {
+    constructor(public stake: Balance, public publicKey: PublicKey) {}
+  }
+
+  export class AddKeyAction {
+    constructor(public publicKey: PublicKey, public accessKey: AccessKey) {}
+  }
+
+  export class DeleteKeyAction {
+    constructor(public publicKey: PublicKey) {}
+  }
+
+  export class DeleteAccountAction {
+    constructor(public beneficiaryId: Account) {}
+  }
+
+  export class ActionValue {
+    constructor(public kind: ActionKind, public data: Payload) {}
+
+    toCreateAccount(): CreateAccountAction {
+      assert(
+        this.kind == ActionKind.CREATE_ACCOUNT,
+        "ActionValue is not a 'CreateAccount'.",
+      )
+      return changetype<CreateAccountAction>(this.data as u32)
+    }
+
+    toDeployContract(): DeployContractAction {
+      assert(
+        this.kind == ActionKind.DEPLOY_CONTRACT,
+        "ActionValue is not a 'DeployContract'.",
+      )
+      return changetype<DeployContractAction>(this.data as u32)
+    }
+
+    toFunctionCall(): FunctionCallAction {
+      assert(
+        this.kind == ActionKind.FUNCTION_CALL,
+        "ActionValue is not a 'FunctionCall'.",
+      )
+      return changetype<FunctionCallAction>(this.data as u32)
+    }
+
+    toTransfer(): TransferAction {
+      assert(this.kind == ActionKind.TRANSFER, "ActionValue is not a 'Transfer'.")
+      return changetype<TransferAction>(this.data as u32)
+    }
+
+    toStake(): StakeAction {
+      assert(this.kind == ActionKind.STAKE, "ActionValue is not a 'Stake'.")
+      return changetype<StakeAction>(this.data as u32)
+    }
+
+    toAddKey(): AddKeyAction {
+      assert(this.kind == ActionKind.ADD_KEY, "ActionValue is not a 'AddKey'.")
+      return changetype<AddKeyAction>(this.data as u32)
+    }
+
+    toDeleteKey(): DeleteKeyAction {
+      assert(this.kind == ActionKind.DELETE_KEY, "ActionValue is not a 'DeleteKey'.")
+      return changetype<DeleteKeyAction>(this.data as u32)
+    }
+
+    toDeleteAccount(): DeleteAccountAction {
+      assert(
+        this.kind == ActionKind.DELETE_ACCOUNT,
+        "ActionValue is not a 'DeleteAccount'.",
+      )
+      return changetype<DeleteAccountAction>(this.data as u32)
+    }
+
+    static fromCreateAccount(input: CreateAccountAction): ActionValue {
+      return new ActionValue(ActionKind.CREATE_ACCOUNT, changetype<u32>(input))
+    }
+
+    static fromDeployContract(input: DeployContractAction): ActionValue {
+      return new ActionValue(ActionKind.DEPLOY_CONTRACT, changetype<u32>(input))
+    }
+
+    static fromFunctionCall(input: FunctionCallAction): ActionValue {
+      return new ActionValue(ActionKind.FUNCTION_CALL, changetype<u32>(input))
+    }
+
+    static fromTransfer(input: TransferAction): ActionValue {
+      return new ActionValue(ActionKind.TRANSFER, changetype<u32>(input))
+    }
+
+    static fromStake(input: StakeAction): ActionValue {
+      return new ActionValue(ActionKind.STAKE, changetype<u32>(input))
+    }
+
+    static fromAddKey(input: AddKeyAction): ActionValue {
+      return new ActionValue(ActionKind.ADD_KEY, changetype<u32>(input))
+    }
+
+    static fromDeleteKey(input: DeleteKeyAction): ActionValue {
+      return new ActionValue(ActionKind.DELETE_KEY, changetype<u32>(input))
+    }
+
+    static fromDeleteAccount(input: DeleteAccountAction): ActionValue {
+      return new ActionValue(ActionKind.DELETE_ACCOUNT, changetype<u32>(input))
+    }
+  }
+
+  // We don't map ReceiptData
+  export class ActionReceipt {
+    constructor(
+      // Receipt fields
+      public predecessorId: string,
+      public receiverId: string,
+      public id: CryptoHash,
+
+      // ReceiptAction fields
+      public signerId: string,
+      public signerPublicKey: PublicKey,
+      public gasPrice: BigInt,
+      public outputDataReceivers: Array<DataReceiver>,
+      public inputDataIds: Array<CryptoHash>,
+      public actions: Array<ActionValue>,
+    ) {}
+  }
+
+  export enum SuccessStatusKind {
+    VALUE = 0,
+    RECEIPT_ID = 1,
+  }
+
+  // Doesn't have Value suffix because it has
+  // VALUE variant/kind, that would be confusing.
+  export class SuccessStatus {
+    constructor(public kind: SuccessStatusKind, public data: Payload) {}
+
+    toValue(): Bytes {
+      assert(this.kind == SuccessStatusKind.VALUE, "SuccessStatus is not a 'Value'.")
+      return changetype<Bytes>(this.data as u32)
+    }
+
+    toReceiptId(): CryptoHash {
+      assert(
+        this.kind == SuccessStatusKind.RECEIPT_ID,
+        "SuccessStatus is not a 'ReceiptId'.",
+      )
+      return changetype<CryptoHash>(this.data as u32)
+    }
+
+    static fromValue(input: Bytes): SuccessStatus {
+      return new SuccessStatus(SuccessStatusKind.VALUE, changetype<u32>(input))
+    }
+
+    static fromReceiptId(input: CryptoHash): SuccessStatus {
+      return new SuccessStatus(SuccessStatusKind.RECEIPT_ID, changetype<u32>(input))
+    }
+  }
+
+  export enum Direction {
+    LEFT = 0,
+    RIGHT = 1,
+  }
+
+  export class MerklePathItem {
+    constructor(public hash: CryptoHash, public direction: Direction) {}
+
+    @operator('<')
+    lt(other: MerklePathItem): boolean {
+      abort("Less than operator isn't supported in MerklePathItem")
+      return false
+    }
+
+    @operator('>')
+    gt(other: MerklePathItem): boolean {
+      abort("Greater than operator isn't supported in MerklePathItem")
+      return false
+    }
+
+    toString(): string {
+      return `{hash: ${this.hash.toString()}}, direction: ${this.direction.toString()}`
+    }
+  }
+
+  export class MerklePath extends Array<MerklePathItem> {}
+
+  export class ExecutionOutcome {
+    constructor(
+      public gasBurnt: u64,
+      public proof: MerklePath,
+      public blockHash: CryptoHash,
+      public id: CryptoHash,
+      public logs: Array<string>,
+      public receiptIds: Array<CryptoHash>,
+      public tokensBurnt: BigInt,
+      public executorId: string,
+      public status: SuccessStatus,
+    ) {}
+  }
+
+  export class SlashedValidator {
+    constructor(public account: Account, public isDoubleSign: bool) {}
+  }
+
+  export class BlockHeader {
+    constructor(
+      public height: BlockHeight,
+      public prevHeight: BlockHeight, // Always zero when version < V3
+      public blockOrdinal: NumBlocks, // Always zero when version < V3
+      public epochId: CryptoHash,
+      public nextEpochId: CryptoHash,
+      public chunksIncluded: u64,
+      public hash: CryptoHash,
+      public prevHash: CryptoHash,
+      public timestampNanosec: u64,
+      public prevStateRoot: CryptoHash,
+      public chunkReceiptsRoot: CryptoHash,
+      public chunkHeadersRoot: CryptoHash,
+      public chunkTxRoot: CryptoHash,
+      public outcomeRoot: CryptoHash,
+      public challengesRoot: CryptoHash,
+      public randomValue: CryptoHash,
+      public validatorProposals: Array<ValidatorStake>,
+      public chunkMask: Array<bool>,
+      public gasPrice: Balance,
+      public totalSupply: Balance,
+      public challengesResult: Array<SlashedValidator>,
+      public lastFinalBlock: CryptoHash,
+      public lastDsFinalBlock: CryptoHash,
+      public nextBpHash: CryptoHash,
+      public blockMerkleRoot: CryptoHash,
+      public epochSyncDataHash: CryptoHash, // Always empty when version < V3
+      public approvals: Array<Signature>, // Array<Option<Signature>>
+      public signature: Signature,
+      public latestProtocolVersion: ProtocolVersion,
+    ) {}
+  }
+
+  export class ValidatorStake {
+    constructor(
+      public account: Account,
+      public publicKey: PublicKey,
+      public stake: Balance,
+    ) {}
+  }
+
+  export class ChunkHeader {
+    constructor(
+      public encodedLength: u64,
+      public gasUsed: Gas,
+      public gasLimit: Gas,
+      public shardId: ShardId,
+      public heightCreated: BlockHeight,
+      public heightIncluded: BlockHeight,
+      public chunkHash: CryptoHash,
+      public signature: Signature,
+      public prevBlockHash: CryptoHash,
+      public prevStateRoot: CryptoHash,
+      public encodedMerkleRoot: CryptoHash,
+      public balanceBurnt: Balance,
+      public outgoingReceiptsRoot: CryptoHash,
+      public txRoot: CryptoHash,
+      public validatorProposals: Array<ValidatorStake>,
+    ) {}
+  }
+
+  export class Block {
+    constructor(
+      public author: Account,
+      public header: BlockHeader,
+      public chunks: Array<ChunkHeader>,
+    ) {}
+  }
+
+  export class ReceiptWithOutcome {
+    constructor(
+      public outcome: ExecutionOutcome,
+      public receipt: ActionReceipt,
+      public block: Block,
+    ) {}
+  }
+}