@sentio/sdk 2.0.0-rc.13 → 2.0.0-rc.15

package/src/aptos/types.ts

@@ -0,0 +1,149 @@
+import { SPLITTER, VECTOR_STR } from './utils.js'
+
+export class TypeDescriptor {
+  // type: string
+
+  // qualified name without type parameters
+  qname: string
+  // account?: string
+  // module?: string
+
+  typeArgs: TypeDescriptor[]
+
+  constructor(symbol: string, typeParams?: TypeDescriptor[]) {
+    this.qname = symbol
+    this.typeArgs = typeParams || []
+  }
+
+  getSignature(): string {
+    if (this.typeArgs.length > 0) {
+      return this.qname + '<' + this.typeArgs.map((t) => t.getSignature()).join(', ') + '>'
+    }
+    return this.qname
+  }
+
+  // Replace T0, T1 with more concrete type
+  applyTypeArgs(ctx: Map<string, TypeDescriptor>): TypeDescriptor {
+    const replace = ctx.get(this.qname)
+    if (replace) {
+      return replace
+    }
+    if (ctx.size === 0 || this.typeArgs.length === 0) {
+      return this
+    }
+
+    const typeArgs: TypeDescriptor[] = []
+    for (const arg of this.typeArgs) {
+      const replace = ctx.get(arg.qname)
+      if (replace) {
+        typeArgs.push(replace)
+      } else {
+        typeArgs.push(arg.applyTypeArgs(ctx))
+      }
+    }
+    return new TypeDescriptor(this.qname, typeArgs)
+  }
+
+  // all depended types including itself, not include system type
+  dependedTypes(): string[] {
+    if (this.qname.startsWith('&')) {
+      return []
+    }
+    switch (this.qname) {
+      case 'signer':
+      case 'address':
+      case '0x1::string::String':
+      case 'bool':
+      case 'u8':
+      case 'u16':
+      case 'u32':
+      case 'u64':
+      case 'u128':
+        return []
+    }
+
+    // Type parameters are not depended
+    if (this.qname.indexOf(SPLITTER) == -1) {
+      if (this.qname.startsWith('T')) {
+        return []
+      }
+    }
+
+    const types = new Set<string>()
+    for (const param of this.typeArgs) {
+      param.dependedTypes().forEach((t) => types.add(t))
+    }
+
+    if (this.qname !== VECTOR_STR) {
+      types.add(this.qname)
+    }
+
+    return Array.from(types)
+  }
+}
+
+export function parseMoveType(type: string): TypeDescriptor {
+  // type = type.replace('&', '')
+
+  type = type.replaceAll('&mut ', '&')
+  type = type.replaceAll('mut ', '')
+
+  // TODO replace ' ' is not exactly safe, need to double check this
+  type = type.replaceAll(' ', '')
+
+  const stack: TypeDescriptor[] = [new TypeDescriptor('')]
+  let buffer = []
+
+  // xxx:asdf<g1<a,<c,d>>, b, g2<a,b>, e>
+  for (let i = 0; i < type.length; i++) {
+    const ch = type[i]
+    if (ch === '<') {
+      // const symbol = type.slice(symbolStart, i)
+      // symbolStart =
+      const symbol = buffer.join('')
+      buffer = []
+      stack[stack.length - 1].qname = symbol
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+    if (ch === '>') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      continue
+    }
+    if (ch === ',') {
+      const typeParam = stack.pop()
+      if (!typeParam) {
+        throw Error('Uxpectecd stack size')
+      }
+      if (buffer.length > 0) {
+        typeParam.qname = buffer.join('')
+        buffer = []
+      }
+
+      stack[stack.length - 1].typeArgs.push(typeParam)
+      // continue parse next param
+      stack.push(new TypeDescriptor(''))
+      continue
+    }
+
+    buffer.push(ch)
+  }
+
+  if (buffer.length > 0) {
+    stack[stack.length - 1].qname = buffer.join('')
+  }
+
+  const res = stack.pop()
+  if (!res || stack.length > 0) {
+    throw Error('Uxpectecd stack size')
+  }
+  return res
+}

package/src/aptos/utils.ts

@@ -0,0 +1,26 @@
+import { MoveFunction, MoveModule } from './move-types.js'
+
+export const SPLITTER = '::'
+
+export const VECTOR_STR = 'vector'
+
+export function isFrameworkAccount(account: string) {
+  return account === '0x1' || account === '0x2' || account === '0x3'
+}
+
+export function moduleQname(module: MoveModule): string {
+  return module.address.toLowerCase() + SPLITTER + module.name
+}
+
+export function moduleQnameForType(type: string): [string, string] {
+  const parts = type.split(SPLITTER).slice(0, 2)
+  return [parts[0], parts[1]]
+}
+
+export function getMeaningfulFunctionParams(func: MoveFunction): string[] {
+  let params = func.params
+  if (func.params[0] === '&signer') {
+    params = params.slice(1)
+  }
+  return params
+}

package/src/builtin/internal/eacaggregatorproxy_processor.ts

@@ -440,71 +440,51 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
   EACAggregatorProxyContractView
 > {
   async accessController(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.accessController(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.accessController(overrides || {});
   }
 
   async aggregator(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.aggregator(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.aggregator(overrides || {});
   }
 
   async decimals(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.decimals(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.decimals(overrides || {});
   }
 
   async description(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.description(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.description(overrides || {});
   }
 
   async getAnswer(
     _roundId: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.getAnswer(_roundId, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.getAnswer(_roundId, overrides || {});
   }
 
   async getRoundData(
@@ -519,58 +499,42 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
       answeredInRound: bigint;
     }
   > {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.getRoundData(_roundId, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.getRoundData(_roundId, overrides || {});
   }
 
   async getTimestamp(
     _roundId: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.getTimestamp(_roundId, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.getTimestamp(_roundId, overrides || {});
   }
 
   async latestAnswer(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.latestAnswer(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.latestAnswer(overrides || {});
   }
 
   async latestRound(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.latestRound(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.latestRound(overrides || {});
   }
 
   async latestRoundData(
@@ -584,84 +548,60 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
       answeredInRound: bigint;
     }
   > {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.latestRoundData(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.latestRoundData(overrides || {});
   }
 
   async latestTimestamp(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.latestTimestamp(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.latestTimestamp(overrides || {});
   }
 
   async owner(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.owner(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.owner(overrides || {});
   }
 
   async phaseAggregators(
     arg0: BigNumberish,
     overrides?: Overrides
   ): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.phaseAggregators(arg0, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.phaseAggregators(arg0, overrides || {});
   }
 
   async phaseId(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.phaseId(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.phaseId(overrides || {});
   }
 
   async proposedAggregator(overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.proposedAggregator(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.proposedAggregator(overrides || {});
   }
 
   async proposedGetRoundData(
@@ -676,16 +616,12 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
       answeredInRound: bigint;
     }
   > {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.proposedGetRoundData(_roundId, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.proposedGetRoundData(_roundId, overrides || {});
   }
 
   async proposedLatestRoundData(
@@ -699,29 +635,21 @@ export class EACAggregatorProxyBoundContractView extends BoundContractView<
       answeredInRound: bigint;
     }
   > {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.proposedLatestRoundData(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.proposedLatestRoundData(overrides || {});
   }
 
   async version(overrides?: Overrides): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.version(overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.version(overrides || {});
   }
 }
 

package/src/builtin/internal/erc1155_processor.ts

@@ -209,16 +209,12 @@ export class ERC1155BoundContractView extends BoundContractView<
     id: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.balanceOf(account, id, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.balanceOf(account, id, overrides || {});
   }
 
   async balanceOfBatch(
@@ -226,16 +222,12 @@ export class ERC1155BoundContractView extends BoundContractView<
     ids: BigNumberish[],
     overrides?: Overrides
   ): Promise<bigint[]> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.balanceOfBatch(accounts, ids, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.balanceOfBatch(accounts, ids, overrides || {});
   }
 
   async isApprovedForAll(
@@ -243,49 +235,33 @@ export class ERC1155BoundContractView extends BoundContractView<
     operator: string,
     overrides?: Overrides
   ): Promise<boolean> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.isApprovedForAll(
-        account,
-        operator,
-        overrides || {}
-      );
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.isApprovedForAll(account, operator, overrides || {});
   }
 
   async supportsInterface(
     interfaceId: BytesLike,
     overrides?: Overrides
   ): Promise<boolean> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.supportsInterface(interfaceId, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.supportsInterface(interfaceId, overrides || {});
   }
 
   async uri(id: BigNumberish, overrides?: Overrides): Promise<string> {
-    try {
-      if (!overrides && this.context) {
-        overrides = {
-          blockTag: toBlockTag(this.context.blockNumber),
-        };
-      }
-      return await this.view.uri(id, overrides || {});
-    } catch (e) {
-      throw transformEtherError(e, this.context);
+    if (!overrides && this.context) {
+      overrides = {
+        blockTag: toBlockTag(this.context.blockNumber),
+      };
     }
+    return await this.view.uri(id, overrides || {});
   }
 }