@sentio/sdk 1.27.9 → 1.28.0

package/src/builtin/aptos/0x3.ts

@@ -7,7 +7,7 @@
 import { aptos } from "@sentio/sdk";
 import { Address, MoveModule } from "aptos-sdk/src/generated";
 
-import { table, event, simple_map, type_info } from "./0x1";
+import * as _0x1 from "./0x1";
 
 export class token extends aptos.AptosBaseProcessor {
   constructor(options: aptos.AptosBindOptions) {
@@ -248,11 +248,11 @@ export namespace token {
 
   export class Collections {
     static TYPE_QNAME = "0x3::token::Collections";
-    collection_data: table.Table<string, token.CollectionData>;
-    token_data: table.Table<token.TokenDataId, token.TokenData>;
-    create_collection_events: event.EventHandle<token.CreateCollectionEvent>;
-    create_token_data_events: event.EventHandle<token.CreateTokenDataEvent>;
-    mint_token_events: event.EventHandle<token.MintTokenEvent>;
+    collection_data: _0x1.table.Table<string, token.CollectionData>;
+    token_data: _0x1.table.Table<token.TokenDataId, token.TokenData>;
+    create_collection_events: _0x1.event.EventHandle<token.CreateCollectionEvent>;
+    create_token_data_events: _0x1.event.EventHandle<token.CreateTokenDataEvent>;
+    mint_token_events: _0x1.event.EventHandle<token.MintTokenEvent>;
   }
 
   export class CreateCollectionEvent {
@@ -382,12 +382,12 @@ export namespace token {
 
   export class TokenStore {
     static TYPE_QNAME = "0x3::token::TokenStore";
-    tokens: table.Table<token.TokenId, token.Token>;
+    tokens: _0x1.table.Table<token.TokenId, token.Token>;
     direct_transfer: Boolean;
-    deposit_events: event.EventHandle<token.DepositEvent>;
-    withdraw_events: event.EventHandle<token.WithdrawEvent>;
-    burn_events: event.EventHandle<token.BurnTokenEvent>;
-    mutate_token_property_events: event.EventHandle<token.MutateTokenPropertyMapEvent>;
+    deposit_events: _0x1.event.EventHandle<token.DepositEvent>;
+    withdraw_events: _0x1.event.EventHandle<token.WithdrawEvent>;
+    burn_events: _0x1.event.EventHandle<token.BurnTokenEvent>;
+    mutate_token_property_events: _0x1.event.EventHandle<token.MutateTokenPropertyMapEvent>;
   }
 
   export class WithdrawCapability {
@@ -535,7 +535,7 @@ export namespace token {
 export namespace property_map {
   export class PropertyMap {
     static TYPE_QNAME = "0x3::property_map::PropertyMap";
-    map: simple_map.SimpleMap<string, property_map.PropertyValue>;
+    map: _0x1.simple_map.SimpleMap<string, property_map.PropertyValue>;
   }
 
   export class PropertyValue {
@@ -630,7 +630,7 @@ export namespace token_coin_swap {
     amount: bigint;
     min_price: bigint;
     locked_until_secs: bigint;
-    coin_type_info: type_info.TypeInfo;
+    coin_type_info: _0x1.type_info.TypeInfo;
   }
 
   export interface TokenListingEventInstance
@@ -641,14 +641,17 @@ export namespace token_coin_swap {
 
   export class TokenListings<T0> {
     static TYPE_QNAME = "0x3::token_coin_swap::TokenListings";
-    listings: table.Table<token.TokenId, token_coin_swap.TokenCoinSwap<T0>>;
-    listing_events: event.EventHandle<token_coin_swap.TokenListingEvent>;
-    swap_events: event.EventHandle<token_coin_swap.TokenSwapEvent>;
+    listings: _0x1.table.Table<
+      token.TokenId,
+      token_coin_swap.TokenCoinSwap<T0>
+    >;
+    listing_events: _0x1.event.EventHandle<token_coin_swap.TokenListingEvent>;
+    swap_events: _0x1.event.EventHandle<token_coin_swap.TokenSwapEvent>;
   }
 
   export class TokenStoreEscrow {
     static TYPE_QNAME = "0x3::token_coin_swap::TokenStoreEscrow";
-    token_escrows: table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
+    token_escrows: _0x1.table.Table<token.TokenId, token_coin_swap.TokenEscrow>;
   }
 
   export class TokenSwapEvent {
@@ -657,7 +660,7 @@ export namespace token_coin_swap {
     token_buyer: Address;
     token_amount: bigint;
     coin_amount: bigint;
-    coin_type_info: type_info.TypeInfo;
+    coin_type_info: _0x1.type_info.TypeInfo;
   }
 
   export interface TokenSwapEventInstance
@@ -784,10 +787,10 @@ export class token_transfers extends aptos.AptosBaseProcessor {
 export namespace token_transfers {
   export class PendingClaims {
     static TYPE_QNAME = "0x3::token_transfers::PendingClaims";
-    pending_claims: table.Table<token_transfers.TokenOfferId, token.Token>;
-    offer_events: event.EventHandle<token_transfers.TokenOfferEvent>;
-    cancel_offer_events: event.EventHandle<token_transfers.TokenCancelOfferEvent>;
-    claim_events: event.EventHandle<token_transfers.TokenClaimEvent>;
+    pending_claims: _0x1.table.Table<token_transfers.TokenOfferId, token.Token>;
+    offer_events: _0x1.event.EventHandle<token_transfers.TokenOfferEvent>;
+    cancel_offer_events: _0x1.event.EventHandle<token_transfers.TokenCancelOfferEvent>;
+    claim_events: _0x1.event.EventHandle<token_transfers.TokenClaimEvent>;
   }
 
   export class TokenCancelOfferEvent {
@@ -875,11 +878,8 @@ export namespace token_transfers {
   );
 }
 
-function loadAllTypes(_r: aptos.TypeRegistry) {
-  table.loadTypes(_r);
-  event.loadTypes(_r);
-  simple_map.loadTypes(_r);
-  type_info.loadTypes(_r);
+export function loadAllTypes(_r: aptos.TypeRegistry) {
+  _0x1.loadAllTypes(_r);
 
   _r.load(token.ABI);
   _r.load(property_map.ABI);

package/src/gen/google/protobuf/timestamp.ts

@@ -0,0 +1,105 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export interface Timestamp {
+  seconds: Long;
+  nanos: number;
+}
+
+function createBaseTimestamp(): Timestamp {
+  return { seconds: Long.ZERO, nanos: 0 };
+}
+
+export const Timestamp = {
+  encode(
+    message: Timestamp,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (!message.seconds.isZero()) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.seconds = reader.int64() as Long;
+          break;
+        case 2:
+          message.nanos = reader.int32();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Timestamp {
+    return {
+      seconds: isSet(object.seconds)
+        ? Long.fromValue(object.seconds)
+        : Long.ZERO,
+      nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Timestamp): unknown {
+    const obj: any = {};
+    message.seconds !== undefined &&
+      (obj.seconds = (message.seconds || Long.ZERO).toString());
+    message.nanos !== undefined && (obj.nanos = Math.round(message.nanos));
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<Timestamp>): Timestamp {
+    const message = createBaseTimestamp();
+    message.seconds =
+      object.seconds !== undefined && object.seconds !== null
+        ? Long.fromValue(object.seconds)
+        : Long.ZERO;
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+  ? string | number | Long
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/gen/service/price/protos/price.ts

@@ -0,0 +1,394 @@
+/* eslint-disable */
+import { CallContext, CallOptions } from "nice-grpc-common";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export interface CoinID {
+  symbol: string | undefined;
+  address: CoinID_AddressIdentifier | undefined;
+}
+
+export interface CoinID_AddressIdentifier {
+  address: string;
+  chain: string;
+}
+
+export interface GetPriceRequest {
+  timestamp: Date | undefined;
+  coinId: CoinID | undefined;
+}
+
+export interface GetPriceResponse {
+  price: number;
+  timestamp: Date | undefined;
+}
+
+function createBaseCoinID(): CoinID {
+  return { symbol: undefined, address: undefined };
+}
+
+export const CoinID = {
+  encode(
+    message: CoinID,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.symbol !== undefined) {
+      writer.uint32(18).string(message.symbol);
+    }
+    if (message.address !== undefined) {
+      CoinID_AddressIdentifier.encode(
+        message.address,
+        writer.uint32(26).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CoinID {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoinID();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 2:
+          message.symbol = reader.string();
+          break;
+        case 3:
+          message.address = CoinID_AddressIdentifier.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CoinID {
+    return {
+      symbol: isSet(object.symbol) ? String(object.symbol) : undefined,
+      address: isSet(object.address)
+        ? CoinID_AddressIdentifier.fromJSON(object.address)
+        : undefined,
+    };
+  },
+
+  toJSON(message: CoinID): unknown {
+    const obj: any = {};
+    message.symbol !== undefined && (obj.symbol = message.symbol);
+    message.address !== undefined &&
+      (obj.address = message.address
+        ? CoinID_AddressIdentifier.toJSON(message.address)
+        : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<CoinID>): CoinID {
+    const message = createBaseCoinID();
+    message.symbol = object.symbol ?? undefined;
+    message.address =
+      object.address !== undefined && object.address !== null
+        ? CoinID_AddressIdentifier.fromPartial(object.address)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseCoinID_AddressIdentifier(): CoinID_AddressIdentifier {
+  return { address: "", chain: "" };
+}
+
+export const CoinID_AddressIdentifier = {
+  encode(
+    message: CoinID_AddressIdentifier,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    if (message.chain !== "") {
+      writer.uint32(18).string(message.chain);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): CoinID_AddressIdentifier {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoinID_AddressIdentifier();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.chain = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CoinID_AddressIdentifier {
+    return {
+      address: isSet(object.address) ? String(object.address) : "",
+      chain: isSet(object.chain) ? String(object.chain) : "",
+    };
+  },
+
+  toJSON(message: CoinID_AddressIdentifier): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    message.chain !== undefined && (obj.chain = message.chain);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<CoinID_AddressIdentifier>
+  ): CoinID_AddressIdentifier {
+    const message = createBaseCoinID_AddressIdentifier();
+    message.address = object.address ?? "";
+    message.chain = object.chain ?? "";
+    return message;
+  },
+};
+
+function createBaseGetPriceRequest(): GetPriceRequest {
+  return { timestamp: undefined, coinId: undefined };
+}
+
+export const GetPriceRequest = {
+  encode(
+    message: GetPriceRequest,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(
+        toTimestamp(message.timestamp),
+        writer.uint32(10).fork()
+      ).ldelim();
+    }
+    if (message.coinId !== undefined) {
+      CoinID.encode(message.coinId, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetPriceRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetPriceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.timestamp = fromTimestamp(
+            Timestamp.decode(reader, reader.uint32())
+          );
+          break;
+        case 2:
+          message.coinId = CoinID.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetPriceRequest {
+    return {
+      timestamp: isSet(object.timestamp)
+        ? fromJsonTimestamp(object.timestamp)
+        : undefined,
+      coinId: isSet(object.coinId) ? CoinID.fromJSON(object.coinId) : undefined,
+    };
+  },
+
+  toJSON(message: GetPriceRequest): unknown {
+    const obj: any = {};
+    message.timestamp !== undefined &&
+      (obj.timestamp = message.timestamp.toISOString());
+    message.coinId !== undefined &&
+      (obj.coinId = message.coinId ? CoinID.toJSON(message.coinId) : undefined);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GetPriceRequest>): GetPriceRequest {
+    const message = createBaseGetPriceRequest();
+    message.timestamp = object.timestamp ?? undefined;
+    message.coinId =
+      object.coinId !== undefined && object.coinId !== null
+        ? CoinID.fromPartial(object.coinId)
+        : undefined;
+    return message;
+  },
+};
+
+function createBaseGetPriceResponse(): GetPriceResponse {
+  return { price: 0, timestamp: undefined };
+}
+
+export const GetPriceResponse = {
+  encode(
+    message: GetPriceResponse,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.price !== 0) {
+      writer.uint32(9).double(message.price);
+    }
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(
+        toTimestamp(message.timestamp),
+        writer.uint32(18).fork()
+      ).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetPriceResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetPriceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.price = reader.double();
+          break;
+        case 2:
+          message.timestamp = fromTimestamp(
+            Timestamp.decode(reader, reader.uint32())
+          );
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetPriceResponse {
+    return {
+      price: isSet(object.price) ? Number(object.price) : 0,
+      timestamp: isSet(object.timestamp)
+        ? fromJsonTimestamp(object.timestamp)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetPriceResponse): unknown {
+    const obj: any = {};
+    message.price !== undefined && (obj.price = message.price);
+    message.timestamp !== undefined &&
+      (obj.timestamp = message.timestamp.toISOString());
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<GetPriceResponse>): GetPriceResponse {
+    const message = createBaseGetPriceResponse();
+    message.price = object.price ?? 0;
+    message.timestamp = object.timestamp ?? undefined;
+    return message;
+  },
+};
+
+export type PriceServiceDefinition = typeof PriceServiceDefinition;
+export const PriceServiceDefinition = {
+  name: "PriceService",
+  fullName: "price_service.PriceService",
+  methods: {
+    getPrice: {
+      name: "GetPrice",
+      requestType: GetPriceRequest,
+      requestStream: false,
+      responseType: GetPriceResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface PriceServiceServiceImplementation<CallContextExt = {}> {
+  getPrice(
+    request: GetPriceRequest,
+    context: CallContext & CallContextExt
+  ): Promise<DeepPartial<GetPriceResponse>>;
+}
+
+export interface PriceServiceClient<CallOptionsExt = {}> {
+  getPrice(
+    request: DeepPartial<GetPriceRequest>,
+    options?: CallOptions & CallOptionsExt
+  ): Promise<GetPriceResponse>;
+}
+
+type Builtin =
+  | Date
+  | Function
+  | Uint8Array
+  | string
+  | number
+  | boolean
+  | undefined;
+
+type DeepPartial<T> = T extends Builtin
+  ? T
+  : T extends Long
+  ? string | number | Long
+  : T extends Array<infer U>
+  ? Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U>
+  ? ReadonlyArray<DeepPartial<U>>
+  : T extends {}
+  ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = numberToLong(date.getTime() / 1_000);
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = t.seconds.toNumber() * 1_000;
+  millis += t.nanos / 1_000_000;
+  return new Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function numberToLong(number: number) {
+  return Long.fromNumber(number);
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/utils/price.ts

@@ -0,0 +1,8 @@
+import { PriceServiceClient, PriceServiceDefinition } from '../gen/service/price/protos/price'
+import { createChannel, createClient } from 'nice-grpc'
+
+export function getPriceClient(address: string): PriceServiceClient {
+  const channel = createChannel(address)
+
+  return createClient(PriceServiceDefinition, channel)
+}