@callcium/sdk 0.10.0 → 0.11.1

package/src/signature.ts

@@ -1,4 +1,5 @@
 import { keccak_256 } from "@noble/hashes/sha3.js";
+import { utf8ToBytes } from "@noble/hashes/utils.js";
 
 import { bytesToHex } from "./bytes";
 import { CallciumError } from "./errors";
@@ -18,13 +19,13 @@ export type ParsedSignature = {
 };
 
 /** Return true if the char code is an ASCII letter. */
-function isAlpha(c: number): boolean {
-  return (c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a);
+function isAlpha(char: number): boolean {
+  return (char >= 0x41 && char <= 0x5a) || (char >= 0x61 && char <= 0x7a);
 }
 
 /** Return true if the char code is an ASCII alphanumeric character. */
-function isAlphanum(c: number): boolean {
-  return isAlpha(c) || (c >= 0x30 && c <= 0x39);
+function isAlphanum(char: number): boolean {
+  return isAlpha(char) || (char >= 0x30 && char <= 0x39);
 }
 
 /**
@@ -36,29 +37,27 @@ function isAlphanum(c: number): boolean {
  * @param signature - A function signature string, e.g. `"transfer(address,uint256)"`.
  * @returns The 4-byte selector and the comma-separated types string.
  * @throws {CallciumError} with code `"MALFORMED_SIGNATURE"`, `"SIGNATURE_CONTAINS_WHITESPACE"`, or
- * `"INVALID_FUNCTION_NAME"` if the signature is malformed.
+ * `"INVALID_FUNCTION_NAME"` if the signature is malformed. The types between the parentheses are
+ * returned unread; whether they name types is for the type parser to say.
  */
 function parse(signature: string): ParsedSignature {
   if (signature.length < 3) {
     throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: too short, got "${signature}"`);
   }
 
-  // Scan for whitespace, non-ASCII, and the opening parenthesis in one pass.
+  // Scan for whitespace and the opening parenthesis in one pass.
   let openParen = -1;
   for (let i = 0; i < signature.length; i++) {
-    const c = signature.charCodeAt(i);
-    if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) {
+    const char = signature.charCodeAt(i);
+    if (char === 0x20 || char === 0x09 || char === 0x0a || char === 0x0d) {
       throw new CallciumError("SIGNATURE_CONTAINS_WHITESPACE", "Signature must not contain whitespace");
     }
-    if (c > 0x7e) {
-      throw new CallciumError("MALFORMED_SIGNATURE", "Signature must contain only ASCII characters");
-    }
-    if (openParen === -1 && c === 0x28) {
+    if (openParen === -1 && char === 0x28) {
       openParen = i;
     }
   }
 
-  if (openParen < 1) {
+  if (openParen === -1) {
     throw new CallciumError(
       "MALFORMED_SIGNATURE",
       `Invalid signature: must have a function name followed by parentheses, got "${signature}"`,
@@ -69,14 +68,19 @@ function parse(signature: string): ParsedSignature {
     throw new CallciumError("MALFORMED_SIGNATURE", `Invalid signature: must end with ")", got "${signature}"`);
   }
 
-  // Validate function name: [A-Za-z_][A-Za-z0-9_]*.
+  if (openParen === 0) {
+    throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must not be empty");
+  }
+
+  // Validate function name: [A-Za-z_][A-Za-z0-9_]*. Every character outside ASCII carries a code
+  // unit above the alphanumeric ranges, so the same test rejects it.
   const firstChar = signature.charCodeAt(0);
   if (!isAlpha(firstChar) && firstChar !== 0x5f) {
     throw new CallciumError("INVALID_FUNCTION_NAME", "Function name must start with a letter or underscore");
   }
   for (let i = 1; i < openParen; i++) {
-    const c = signature.charCodeAt(i);
-    if (!isAlphanum(c) && c !== 0x5f) {
+    const char = signature.charCodeAt(i);
+    if (!isAlphanum(char) && char !== 0x5f) {
       throw new CallciumError(
         "INVALID_FUNCTION_NAME",
         "Function name must contain only alphanumeric characters or underscores",
@@ -84,9 +88,7 @@ function parse(signature: string): ParsedSignature {
     }
   }
 
-  const encoded = new Uint8Array(signature.length);
-  for (let i = 0; i < signature.length; i++) encoded[i] = signature.charCodeAt(i);
-  const hash = keccak_256(encoded);
+  const hash = keccak_256(utf8ToBytes(signature));
 
   const selector = bytesToHex(hash.subarray(0, 4));
   const types = signature.slice(openParen + 1, signature.length - 1);

package/src/type-desc.ts

@@ -77,14 +77,14 @@ export function string_(): Uint8Array {
 
 /**
  * Build a descriptor node for `bytesN`.
- * @param n - Byte width, 1–32.
- * @throws {CallciumError} With code `UNKNOWN_TYPE` if n is out of range.
+ * @param length - Byte width, 1–32.
+ * @throws {CallciumError} With code `UNKNOWN_TYPE` if length is out of range.
  */
-export function bytesN(n: number): Uint8Array {
-  if (n < 1 || n > 32) {
-    throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${n}. Must be 1–32`);
+export function bytesN(length: number): Uint8Array {
+  if (length < 1 || length > 32) {
+    throw new CallciumError("UNKNOWN_TYPE", `Invalid bytesN size: ${length}. Must be 1–32`);
   }
-  return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (n - 1)]);
+  return new Uint8Array([TypeCode.FIXED_BYTES_MIN + (length - 1)]);
 }
 
 ///////////////////////////////////////////////////////////////////////////