@avaprotocol/sdk-js 0.6.4 → 0.6.6

package/dist/index.js

@@ -11,6 +11,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,7 +27,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // grpc_codegen/avs_pb.js
 var avs_pb_exports = {};
-var jspb, goog, global, google_protobuf_timestamp_pb, google_protobuf_wrappers_pb;
+__export(avs_pb_exports, {
+  CreateTaskReq: () => CreateTaskReq,
+  CreateTaskResp: () => CreateTaskResp,
+  GetKeyReq: () => GetKeyReq,
+  KeyResp: () => KeyResp,
+  Task: () => Task,
+  UpdateChecksReq: () => UpdateChecksReq,
+  UpdateChecksResp: () => UpdateChecksResp
+});
+var jspb, goog, global, google_protobuf_timestamp_pb, google_protobuf_wrappers_pb, Task, CreateTaskReq, CreateTaskResp, GetKeyReq, KeyResp, UpdateChecksReq, UpdateChecksResp;
 var init_avs_pb = __esm({
   "grpc_codegen/avs_pb.js"() {
     "use strict";
@@ -4084,12 +4097,29 @@ var init_avs_pb = __esm({
       JAVASCRIPT: 0
     };
     goog.object.extend(exports, proto.aggregator);
+    ({ Task, CreateTaskReq, CreateTaskResp, GetKeyReq, KeyResp, UpdateChecksReq, UpdateChecksResp } = proto.aggregator);
   }
 });
 
 // src/index.ts
 import * as grpc2 from "@grpc/grpc-js";
-import { Metadata } from "@grpc/grpc-js";
+
+// src/config.ts
+var DEFAULT_JWT_EXPIRATION = 24 * 60 * 60;
+var configs = {
+  development: {
+    AVS_RPC_URL: process.env.AVS_RPC_URL || "localhost:2206"
+  },
+  staging: {
+    AVS_RPC_URL: "aggregator-holesky.avaprotocol.org:2206"
+  },
+  production: {
+    AVS_RPC_URL: "aggregator.avaprotocol.org:2206"
+  }
+};
+function getRpcEndpoint(env) {
+  return configs[env].AVS_RPC_URL;
+}
 
 // src/auth.ts
 var getKeyRequestMessage = (address, expiredAt) => {
@@ -4272,7 +4302,7 @@ function serialize_google_protobuf_BoolValue(arg) {
 function deserialize_google_protobuf_BoolValue(buffer_arg) {
   return google_protobuf_wrappers_pb2.BoolValue.deserializeBinary(new Uint8Array(buffer_arg));
 }
-var AggregatorService = exports.AggregatorService = {
+var AggregatorService = {
   // Auth
   getKey: {
     path: "/aggregator.Aggregator/GetKey",
@@ -4399,20 +4429,20 @@ var AggregatorService = exports.AggregatorService = {
     responseDeserialize: deserialize_aggregator_UpdateChecksResp
   }
 };
-exports.AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
+var AggregatorClient = grpc.makeGenericClientConstructor(AggregatorService);
 
 // src/index.ts
 init_avs_pb();
-var grpcMetadata = new Metadata();
+var metadata = new grpc2.Metadata();
 var BaseClient = class {
-  // A JWT token for admin operations
-  // protected wallet?: any;
-  constructor(config) {
-    this.endpoint = config.endpoint;
-    this.rpcClient = new (void 0)(
-      config.endpoint,
+  constructor(opts) {
+    this.env = opts.env || "production";
+    this.rpcClient = new AggregatorClient(
+      getRpcEndpoint(this.env),
+      // TODO: switch to the TLS after we're able to update all the operator
       grpc2.credentials.createInsecure()
     );
+    console.log("this.rpcClient:", this.rpcClient);
   }
   // async authWithJwtToken(
   //   address: string,
@@ -4420,21 +4450,21 @@ var BaseClient = class {
   //   expiredAt?: number
   // ): Promise<KeyExchangeResp> {
   //   console.log("Authenticating with JWT token: ", jwtToken);
+  //   // Use the provided expiredAt or set it to 24 hours from now if not provided
   //   const expirationTime =
   //     expiredAt || Math.floor(Date.now() / 1000) + DEFAULT_JWT_EXPIRATION;
-  //   const method = this.rpcClient.getKey.bind(this.rpcClient) as (
-  //     request: GetKeyReq,
-  //     metadata: Metadata | undefined,
-  //     callback: (error: grpc.ServiceError | null, response: KeyResp) => void
-  //   ) => grpc.ClientUnaryCall;
-  //   const request = new GetKeyReq()
-  //     .setOwner(address)
-  //     .setExpiredAt(expirationTime)
-  //     .setSignature(jwtToken);
-  //   const response = await this._callRPC<KeyResp, GetKeyReq>(method, request);
-  //   console.log("response:", response.getKey());
-  //   return { key: response.getKey() };
+  //   const result: avsPb.KeyResp = await this._callRPC<
+  //     avsPb.KeyResp,
+  //     avsPb.GetKeyReq
+  //   >("getKey", {
+  //     owner: address,
+  //     expired_at: expirationTime,
+  //     signature: jwtToken,
+  //   });
+  //   this.authkey = result.getKey();
+  //   return { key: result.getKey() };
   // }
+  // This flow can be used where the signature is generate from outside, such as in front-end and pass in
   async authWithSignature(address, signature, expiredAtEpoch) {
     console.log(
       "Authenticating with signature:",
@@ -4442,52 +4472,29 @@ var BaseClient = class {
       "Expired at epoch:",
       expiredAtEpoch
     );
-    const request = new (void 0)().setOwner(address).setExpiredAt(expiredAtEpoch).setSignature(signature);
-    console.log("request:", request);
-    const response = await this._callRPC("getKey", request);
-    console.log("response:", response.getKey());
-    return { key: response.getKey() };
+    const request = new GetKeyReq();
+    request.setOwner(address);
+    request.setExpiredAt(expiredAtEpoch);
+    request.setSignature(signature);
+    let result = await this._callRPC(
+      "getKey",
+      request
+    );
+    console.log("result:", result);
+    this.authkey = result.getKey();
+    return { key: result.getKey() };
   }
-  // protected async sendRequest<TResponse, TRequest extends object = {}>(
-  //   method: string,
-  //   request: TRequest = {} as TRequest,
-  //   metadata?: Metadata
-  // ): Promise<TResponse> {
-  //   if (metadata === undefined) {
-  //     metadata = new grpc.Metadata();
-  //   }
-  //   if (!this.adminToken) {
-  //     throw new Error(
-  //       "Authentication required. Please call authWithJwtToken() or authWithSignature() before making requests."
-  //     );
-  //   }
-  //   metadata.add("adminToken", this.adminToken);
-  //   return this._callRPC<TResponse, TRequest>(
-  //     method as (
-  //       request: TRequest,
-  //       metadata: grpc.Metadata | undefined,
-  //       callback: (error: grpc.ServiceError | null, response: TResponse) => void
-  //     ),
-  //     request,
-  //     metadata
-  //   );
-  // }
   isAuthenticated() {
-    return !!this.adminToken;
+    return !!this.authkey;
   }
-  _callRPC(methodName, request) {
+  _callRPC(method, request) {
     return new Promise((resolve, reject) => {
-      const method = this.rpcClient[methodName];
-      method.call(
-        this.rpcClient,
+      this.rpcClient[method].bind(this.rpcClient)(
         request,
-        grpcMetadata,
+        metadata,
         (error, response) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(response);
-          }
+          if (error) reject(error);
+          else resolve(response);
         }
       );
     });
@@ -4497,32 +4504,8 @@ var Client = class extends BaseClient {
   constructor(config) {
     super(config);
   }
-  async listTask() {
-    console.log("Listing tasks");
-    const request = new (void 0)();
-    const response = await this._callRPC(
-      "listTasks",
-      request
-    );
-    console.log("response:", response);
-    return response;
-  }
-  async getSmartWalletAddress(address) {
-    const request = new (void 0)().setOwner(address);
-    const response = await this._callRPC(
-      "getSmartAccountAddress",
-      request
-    );
-    return response;
-  }
-  async getTask(taskId) {
-    const request = new (void 0)().setBytes(taskId);
-    const response = await this._callRPC("getTask", request);
-    return response;
-  }
 };
 export {
-  BaseClient,
-  Client,
+  Client as default,
   getKeyRequestMessage
 };

package/grpc_codegen/avs.proto

@@ -0,0 +1,297 @@
+syntax = "proto3";
+package aggregator;
+
+option go_package = "./avsproto";
+
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+message UUID {
+  string bytes = 1;
+}
+
+message Checkin {
+  string id = 1;
+  string address = 2;
+  string signature = 3;
+
+  message Status {
+    int64 uptime = 1;
+    int64 queueDepth = 2;
+    google.protobuf.Timestamp last_heartbeat = 3;
+  }
+
+  Status status = 4;
+
+  string version = 5;
+  int32 metricsPort = 6;
+  string remoteIP = 7;
+}
+
+message CheckinResp {
+  google.protobuf.Timestamp updated_at = 1;
+}
+
+message SyncTasksReq {
+  string id = 1;
+  string address = 2;
+  string signature = 3;
+  int64  monotonic_clock = 4;
+}
+
+enum TriggerType {
+  TimeTrigger          = 0;
+  ContractQueryTrigger = 1;
+  ExpressionTrigger    = 2;
+}
+
+message TaskTrigger {
+  TriggerType            trigger_type   = 1;
+
+  TimeCondition          schedule       = 2;
+  ContractQueryCondition contract_query = 3;
+  ExpressionCondition    expression     = 4;
+}
+
+// Simple timebase or cron syntax.
+message TimeCondition {
+  repeated int64 fixed = 1;
+  string cron = 2;
+}
+// A contract method that return true/false
+// Ideally to use when we already have an existing contract that perform the
+// check.
+// This method will be evaluate every block
+message ContractQueryCondition {
+  string contract_address = 1;
+  string callmsg = 2;
+}
+
+// An arbitrary expression to express the condition.
+// People can define condition example
+//   chainlinkPrice("address-of-eth-usd-pair") > 2644500 && queryContract("contractaddress", "callmsg")[2] < = 5
+// By allow arbitrary expression, people can mix and match to create conplex
+// condition that match their workload
+//
+// The function to be used need to be pre-defined on our task egnine runtime.
+// When a new block is build, our engine will execute these check
+//
+// The expression language is re-present by https://expr-lang.org/
+message ExpressionCondition {
+  string expression = 1;
+}
+
+message SyncTasksResp {
+  string id        = 1;
+  string checkType = 2;
+
+  TaskTrigger trigger = 3;
+}
+
+// TaskType represents what kind of work the task will perform
+enum TaskType {
+  // Handle default/missing data
+  ETHTransferTask = 0;
+  
+  // Generic contract execution which can be used for:
+  // ERC20 Transfer, NFT Transfer, auto reclaim, auto restaking etc
+  // When executing a contract we need at least 2 things:
+  // - target contract address
+  // - the message to send to that contract
+  ContractExecutionTask = 1;
+
+  GraphQLDataQueryTask = 2;
+  // Make call to a HTTP endpoint
+  HTTPAPICallTask = 3;
+  // CustomCode allow to run arbitraty JavaScript.
+  CustomCodeTask = 4;
+  BranchActionTask = 5;
+}
+
+// TaskStatus represents status of the task. The transition is as follow
+enum TaskStatus {
+  Active = 0;
+  Completed = 1;
+  Failed = 2;
+  Canceled = 3;
+  Executing = 4;
+}
+
+message ETHTransfer {
+  string destination = 1;
+  string amount = 2;
+}
+
+message ContractExecution {
+  string contract_address = 1;
+  string call_data = 2;
+
+  string method = 3;
+  string encoded_params = 4;
+}
+
+message GraphQLDataQuery {
+  // TODO: support graphql variable
+  string url   = 1;
+  string query = 2;
+}
+
+message HTTPAPICall {
+  string              url     = 1;
+  map<string, string> headers = 2;
+  string              body    = 3;
+}
+
+enum CustomCodeType {
+  JavaScript = 0;
+}
+
+message CustomCode {
+  CustomCodeType type     = 1;
+  string          body    = 2;
+}
+
+message ConditionJump {
+  string expression  = 1;
+  string next        = 2;
+}
+
+message BranchAction {
+  ConditionJump If                  = 1;
+  repeated ConditionJump ElseIfs    = 2;
+  ConditionJump Else                = 3;
+}
+
+message TaskAction {
+  TaskType task_type = 1;
+
+  string id = 2;
+  string name = 3;
+
+  // Next can be empty. In some kind of block, such as branching, the next is
+  // based on branching condition
+  repeated string next = 4;
+
+  // Transfer eth
+  ETHTransfer eth_transfer = 10;
+  // Run one ore more contracts. The call call also be batched with tool like
+  // multicall to wrap many calls
+  ContractExecution contract_execution = 11;
+  // Make call to a graphql endpoint
+  GraphQLDataQuery graphql_data_query = 12;
+  // Make call to a HTTP endpoint
+  HTTPAPICall http_data_query = 13;
+  // CustomCode allow to run arbitraty JavaScript.
+  CustomCode custom_code = 14;
+  BranchAction branch = 15;
+}
+
+message Execution {
+  int64 epoch = 1;
+  string user_op_hash = 2;
+  string error = 3;
+}
+
+message Task {
+    UUID id = 1;
+    string owner = 2;
+    string smart_account_address = 3;
+    TaskTrigger trigger = 4;
+    repeated TaskAction nodes = 5;
+
+    // task won't be check before this
+    int64 start_at = 6;
+    // task won't be run/check after this
+    int64 expired_at = 7;
+    // arbitrary data about this task
+    string memo = 8;
+
+    int64 completed_at = 9;
+    TaskStatus status  = 10;
+    // repeatable means a task can continue to run even after the first execution
+    bool repeatable  = 11;
+    repeated Execution executions = 12;
+}
+
+message CreateTaskReq {
+  TaskTrigger trigger = 1;
+  repeated TaskAction actions  = 2;
+  int64 start_at      = 3;
+  int64 expired_at    = 4;
+  string memo         = 5;
+  // A repeatable task will continue to be run
+  bool repeatable     = 6;
+}
+
+message CreateTaskResp {
+    string id = 1;
+}
+
+message NonceRequest {
+    string owner = 1;
+}
+
+message NonceResp {
+    string nonce = 1;
+}
+
+message AddressRequest {
+    string owner = 1;
+}
+
+message AddressResp {
+    string smart_account_address = 1;
+    string nonce = 2;
+}
+
+message ListTasksReq {}
+
+message ListTasksResp {
+    message TaskItemResp {
+        string id = 1;
+        TaskStatus status = 2;
+    }
+
+    repeated TaskItemResp tasks = 1;
+}
+
+message GetKeyReq {
+    string owner = 1;
+    int64  expired_at = 2;
+    string signature = 3;
+}
+
+message KeyResp {
+    string key=1;
+}
+
+message UpdateChecksReq {
+  string address = 1;
+  string signature = 2;
+  repeated string id = 3;
+}
+
+message UpdateChecksResp {
+  google.protobuf.Timestamp updated_at = 1;
+}
+
+service Aggregator {
+  // Auth
+  rpc GetKey(GetKeyReq) returns (KeyResp) {};
+
+  // Smart Acccount
+  rpc GetNonce(NonceRequest) returns (NonceResp) {};
+  rpc GetSmartAccountAddress(AddressRequest) returns (AddressResp) {};
+
+  // Task Management
+  rpc CreateTask(CreateTaskReq) returns (CreateTaskResp) {};
+  rpc ListTasks(ListTasksReq) returns (ListTasksResp) {};
+  rpc GetTask(UUID) returns (Task) {};
+  rpc CancelTask(UUID) returns (google.protobuf.BoolValue) {};
+  rpc DeleteTask(UUID) returns (google.protobuf.BoolValue) {};
+
+  // Operator endpoint
+  rpc Ping(Checkin) returns (CheckinResp) {};
+  rpc SyncTasks(SyncTasksReq) returns (stream SyncTasksResp) {};
+  rpc UpdateChecks(UpdateChecksReq) returns (UpdateChecksResp) {};
+}