datai-sdk 1.1.1 → 1.1.3

package/@graphprotocol/graph-ts/index.ts

@@ -0,0 +1,156 @@
+// Side-effect to evaluate eagerly the offset of stub AS runtime
+import './common/eager_offset';
+import { ByteArray, Bytes, Entity } from './common/collections';
+import { Value } from './common/value';
+
+// Arweave support
+export * from './chain/arweave';
+// Ethereum support
+export * from './chain/ethereum';
+// NEAR support
+export * from './chain/near';
+// Cosmos support
+export * from './chain/cosmos';
+// Starknet support
+export * from './chain/starknet';
+// Regular re-exports
+export * from './common/collections';
+export * from './common/conversion';
+export * from './common/datasource';
+export * from './common/json';
+export * from './common/numbers';
+export * from './common/value';
+import * as API from '../../../API'
+export { store, crypto } from '../../../API';
+
+
+// /** 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 namespace ipfs {
+//   export function mapJSON(hash: string, callback: string, userData: Value): void {
+//     ipfs.map(hash, callback, userData, ['json']);
+//   }
+// }
+
+// /**
+//  * 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;
+// }
+
+function format(fmt: string, args: string[]): string {
+  let out = '';
+  let argIndex = 0;
+  for (let i: i32 = 0, len: i32 = fmt.length; i < len; i++) {
+    if (
+      i < len - 1 &&
+      fmt.charCodeAt(i) == 0x7b /* '{' */ &&
+      fmt.charCodeAt(i + 1) == 0x7d /* '}' */
+    ) {
+      if (argIndex >= args.length) {
+        throw new Error('Too few arguments for format string: ' + fmt);
+      } else {
+        out += args[argIndex++];
+        i++;
+      }
+    } else {
+      out += fmt.charAt(i);
+    }
+  }
+  return out;
+}
+
+export namespace log {
+  export const log = API.log.log;
+
+  export 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.
+   */
+  export function critical(msg: string, args: Array<string>): void {
+    log(Level.CRITICAL, format(msg, args));
+  }
+
+  /**
+   * Logs an error message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function error(msg: string, args: Array<string>): void {
+    log(Level.ERROR, format(msg, args));
+  }
+
+  /** Logs a warning message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function warning(msg: string, args: Array<string>): void {
+    log(Level.WARNING, format(msg, args));
+  }
+
+  /** Logs an info message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function info(msg: string, args: Array<string>): void {
+    log(Level.INFO, format(msg, args));
+  }
+
+  /** Logs a debug message.
+   *
+   * @param msg Format string a la "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function debug(msg: string, args: Array<string>): void {
+    log(Level.DEBUG, format(msg, args));
+  }
+}
+
+/**
+ * Helper functions for Ethereum.
+ */
+export 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.
+   */
+  export function getCreate2Address(from: Bytes, salt: Bytes, initCodeHash: Bytes): Bytes {
+    return Bytes.fromHexString(
+      Bytes.fromByteArray(
+        API.crypto.keccak256(
+          Bytes.fromHexString(
+            '0xff' +
+              from.toHexString().slice(2) +
+              salt.toHexString().slice(2) +
+              initCodeHash.toHexString().slice(2),
+          ),
+        ),
+      )
+        .toHexString()
+        .slice(26),
+    );
+  }
+}

package/@graphprotocol/graph-ts/package.json

@@ -0,0 +1,3 @@
+{
+  "ascMain": "index.ts"
+}

package/@graphprotocol/graph-ts/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../../../node_modules/assemblyscript/std/assembly.json",
+  "include": ["index.ts", "helper-functions.ts", "global/global.ts", "test"]
+}

package/@graphprotocol/graph-ts/types/tsconfig.base.json

@@ -0,0 +1,3 @@
+{
+  "extends": "assemblyscript/std/assembly"
+}

package/API/v1/proto/activePositions/activePositions/ActivePositionsResultPb.ts

@@ -5,7 +5,7 @@
 
 import { Writer, Reader } from "as-proto/assembly";
 import { TokenBalancePb } from "./TokenBalancePb";
-import { Timestamp } from "../google/protobuf/Timestamp";
+import { Timestamp } from "../../google/protobuf/Timestamp";
 import { NftItemPb } from "./NftItemPb";
 import { PerpPositionPb } from "./PerpPositionPb";
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "datai-sdk",
   "main": "index.ts",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Datai SDK which has useful libraries to help building projections",
   "scripts": {
     "postinstall": "node postinstall-script.js"

package/patch-graph-ts.js

@@ -0,0 +1,70 @@
+/**
+ * Patch @graphprotocol/graph-ts to fix AssemblyScript type inference issue
+ * 
+ * The issue: `assert(this !== null, ...)` in BigInt/BigDecimal methods causes
+ * AssemblyScript to infer `this` as `T | null`, which breaks type checking.
+ * 
+ * This script removes the problematic assertions since:
+ * 1. In AssemblyScript, `this` in a class method can never be null when called normally
+ * 2. The assertions were added for defensive purposes but break compilation
+ * 
+ * Run this script after `npm install` in the consuming project.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Find the graph-ts installation
+const possiblePaths = [
+  path.resolve(__dirname, 'node_modules/@graphprotocol/graph-ts/common/numbers.ts'),
+  path.resolve(__dirname, '../node_modules/@graphprotocol/graph-ts/common/numbers.ts'),
+  path.resolve(process.cwd(), 'node_modules/@graphprotocol/graph-ts/common/numbers.ts'),
+];
+
+let numbersPath = null;
+for (const p of possiblePaths) {
+  if (fs.existsSync(p)) {
+    numbersPath = p;
+    break;
+  }
+}
+
+if (!numbersPath) {
+  console.log('graph-ts numbers.ts not found. Skipping patch (may already be patched or graph-ts not installed).');
+  process.exit(0);
+}
+
+console.log(`Patching ${numbersPath}...`);
+
+let content = fs.readFileSync(numbersPath, 'utf8');
+
+// Pattern to match assertions like:
+// assert(this !== null, "Failed to ... because left hand side is 'null'");
+// or "... value of it is 'null'"
+// We match the entire line including leading whitespace and newline
+// Handles optional whitespace after the semicolon
+const assertPattern = /^\s*assert\(this !== null, "Failed to [^"]+"\);\s*\n/gm;
+
+// Count matches
+const matches = content.match(assertPattern);
+if (!matches || matches.length === 0) {
+  console.log('File appears to already be patched or has different format. Skipping.');
+  process.exit(0);
+}
+
+console.log(`Found ${matches.length} assertions to remove.`);
+
+// Remove the problematic assertions (replace with empty string to preserve next line's indentation)
+const patched = content.replace(assertPattern, '');
+
+// Backup original
+const backupPath = numbersPath + '.bak';
+if (!fs.existsSync(backupPath)) {
+  fs.writeFileSync(backupPath, content);
+  console.log(`Backup created at ${backupPath}`);
+}
+
+// Write patched version
+fs.writeFileSync(numbersPath, patched);
+console.log('Patch applied successfully!');
+console.log('Removed assert(this !== null, ...) statements from BigInt and BigDecimal methods.');

package/postinstall-script.js

@@ -9,28 +9,34 @@ const destinationFolder = path.resolve(
 );
 
 // Check if the source folder exists
-// If it doesn't exist, the script was likely already run or this is an npm install
-// In either case, we can safely exit without error
-if (!fs.existsSync(sourceFolder)) {
-  console.log(`Source folder "${sourceFolder}" does not exist. Skipping postinstall (already configured or installed from npm).`);
-  process.exit(0);
-}
+// The @graphprotocol folder contains a custom fork of graph-ts that integrates
+// with the SDK's host functions (bigInt, bigDecimal, ethereum.call, etc.)
+if (fs.existsSync(sourceFolder)) {
+  // Create node_modules folder if it doesn't exist
+  const nodeModulesPath = path.resolve(__dirname, "node_modules");
+  if (!fs.existsSync(nodeModulesPath)) {
+    fs.mkdirSync(nodeModulesPath);
+  }
 
-// Create node_modules folder if it doesn't exist
-const nodeModulesPath = path.resolve(__dirname, "node_modules");
-if (!fs.existsSync(nodeModulesPath)) {
-  fs.mkdirSync(nodeModulesPath);
-}
+  // Check if the destination folder already exists
+  if (fs.existsSync(destinationFolder)) {
+    console.log(
+      `Destination folder "${destinationFolder}" already exists. Removing it...`
+    );
+    fs.rmSync(destinationFolder, { recursive: true, force: true });
+  }
 
-// Check if the destination folder already exists
-if (fs.existsSync(destinationFolder)) {
-  console.log(
-    `Destination folder "${destinationFolder}" already exists. Removing it...`
-  );
-  fs.rmSync(destinationFolder, { recursive: true, force: true });
-}
+  // Move the source folder to node_modules
+  // This makes the custom graph-ts available to watchers that use the SDK
+  fs.renameSync(sourceFolder, destinationFolder);
 
-// Move the source folder to node_modules
-fs.renameSync(sourceFolder, destinationFolder);
-
-console.log(`Folder "${sourceFolder}" moved to "${destinationFolder}".`);
+  console.log(`Folder "${sourceFolder}" moved to "${destinationFolder}".`);
+  console.log("Custom graph-ts (integrated with SDK host functions) is now available.");
+} else if (fs.existsSync(destinationFolder)) {
+  // Folder already moved in a previous install - this is fine
+  console.log("Custom graph-ts already installed in node_modules.");
+} else {
+  // This shouldn't happen in normal usage, but warn instead of error
+  console.warn(`Warning: Source folder "${sourceFolder}" does not exist.`);
+  console.warn("If this is an npm install, the @graphprotocol folder should be included in the package.");
+}

package/API/v1/proto/activePositions/google/protobuf/Timestamp.ts

@@ -1,48 +0,0 @@
-// Code generated by protoc-gen-as. DO NOT EDIT.
-// Versions:
-//   protoc-gen-as v1.3.0
-//   protoc        v6.33.4
-
-import { Writer, Reader } from "as-proto/assembly";
-
-export class Timestamp {
-  static encode(message: Timestamp, writer: Writer): void {
-    writer.uint32(8);
-    writer.int64(message.seconds);
-
-    writer.uint32(16);
-    writer.int32(message.nanos);
-  }
-
-  static decode(reader: Reader, length: i32): Timestamp {
-    const end: usize = length < 0 ? reader.end : reader.ptr + length;
-    const message = new Timestamp();
-
-    while (reader.ptr < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.seconds = reader.int64();
-          break;
-
-        case 2:
-          message.nanos = reader.int32();
-          break;
-
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-
-    return message;
-  }
-
-  seconds: i64;
-  nanos: i32;
-
-  constructor(seconds: i64 = 0, nanos: i32 = 0) {
-    this.seconds = seconds;
-    this.nanos = nanos;
-  }
-}