@thru/programs 0.2.30 → 0.2.32

package/src/helpers/bytes.ts

@@ -0,0 +1,25 @@
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+export function compareBytes(a: Uint8Array, b: Uint8Array): number {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return a.length - b.length;
+}
+
+export function uniqueAccounts(accounts: Uint8Array[]): Uint8Array[] {
+  const unique: Uint8Array[] = [];
+  for (const account of accounts) {
+    if (!unique.some((candidate) => bytesEqual(candidate, account))) {
+      unique.push(account);
+    }
+  }
+  return unique;
+}

package/src/multicall/abi/thru/common/primitives/types.ts

@@ -1106,7 +1106,7 @@ export class DurationBuilder {
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
 
-  set_seconds(value: number): this {
+  set_seconds(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigInt64(0, cast, true);
     return this;
@@ -1270,7 +1270,7 @@ export class FixedPointBuilder {
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
 
-  set_mantissa(value: number): this {
+  set_mantissa(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigInt64(0, cast, true);
     return this;
@@ -1756,7 +1756,7 @@ export class InstructionDataBuilder {
     return this;
   }
 
-  set_data_size(value: number): this {
+  set_data_size(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigUint64(2, cast, true);
     this.__tnInvalidate();
@@ -1770,7 +1770,7 @@ export class InstructionDataBuilder {
         const elementCount = bytes.length;
         this.__tnFam_data = bytes;
         this.__tnFam_dataCount = elementCount;
-        this.set_data_size(elementCount);
+        this.set_data_size(__tnToBigInt(elementCount));
         this.__tnInvalidate();
       });
     }
@@ -2241,7 +2241,7 @@ export class TimestampBuilder {
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
 
-  set_seconds(value: number): this {
+  set_seconds(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigInt64(0, cast, true);
     return this;
@@ -2267,4 +2267,3 @@ export class TimestampBuilder {
 __tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
 __tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate("Timestamp", (buffer) => { const result = Timestamp.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
-

package/src/multicall/abi/thru/program/multicall/types.ts

@@ -1335,7 +1335,7 @@ export class MulticallErrorBuilder {
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
 
-  set_code(value: number): this {
+  set_code(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigUint64(0, cast, true);
     return this;
@@ -1361,4 +1361,3 @@ export class MulticallErrorBuilder {
 __tnRegisterFootprint("MulticallError", (params) => MulticallError.__tnInvokeFootprint(params));
 __tnRegisterValidate("MulticallError", (buffer, params) => MulticallError.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate("MulticallError", (buffer) => { const result = MulticallError.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
-

package/src/passkey-manager/abi/thru/blockchain/state_proof/types.ts

@@ -1745,4 +1745,3 @@ export class StateProofBuilder {
 __tnRegisterFootprint("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
 __tnRegisterValidate("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate("StateProof", (buffer) => { const result = StateProof.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
-

package/src/passkey-manager/abi/thru/common/primitives/types.ts

@@ -2267,4 +2267,3 @@ export class TimestampBuilder {
 __tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
 __tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate("Timestamp", (buffer) => { const result = Timestamp.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
-

package/src/passkey-manager/abi/thru/program/passkey_manager/types.ts

@@ -1122,7 +1122,7 @@ export class AuthorityRecordBuilder {
 
 __tnRegisterFootprint("AuthorityRecord", (params) => AuthorityRecord.__tnInvokeFootprint(params));
 __tnRegisterValidate("AuthorityRecord", (buffer, params) => AuthorityRecord.__tnInvokeValidate(buffer, params));
-__tnRegisterDynamicValidate("AuthorityRecord", (buffer) => { const result = AuthorityRecord.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+__tnRegisterDynamicValidate("AuthorityRecord", (buffer) => { const result = AuthorityRecord.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
 
 /* ----- TYPE DEFINITION FOR P256Point ----- */
 
@@ -3993,7 +3993,7 @@ export class PasskeyEventBuilder {
   private __tnComputeParams(): PasskeyEvent.Params {
     if (this.__tnCachedParams) return this.__tnCachedParams;
     const params = PasskeyEvent.Params.fromValues({
-      payload_event_type: (() => { return __tnToBigInt(this.__tnPrefixView.getUint8(0)); })(),
+      payload_event_type: (() => { if (this.__tnField_event_type === null) throw new Error("PasskeyEventBuilder: missing enum tag"); return __tnToBigInt(this.__tnField_event_type); })(),
     });
     this.__tnCachedParams = params;
     return params;
@@ -4083,8 +4083,8 @@ export class CreateArgs {
     const __tnRead_wallet_account_idx = view.getUint16(__tnCursorMutable, true);
     __tnFieldValue_wallet_account_idx = __tnRead_wallet_account_idx;
     __tnCursorMutable += 2;
-    if (__tnCursorMutable + 65 > __tnLength) return null;
-    __tnCursorMutable += 65;
+    if (__tnCursorMutable + 73 > __tnLength) return null;
+    __tnCursorMutable += 73;
     if (__tnCursorMutable + 32 > __tnLength) return null;
     __tnCursorMutable += 32;
     const __tnTyperefResult_state_proof = __tnInvokeDynamicValidate("StateProof", buffer.subarray(__tnCursorMutable));
@@ -5360,4 +5360,3 @@ export class PasskeyInstructionBuilder {
 __tnRegisterFootprint("PasskeyInstruction", (params) => PasskeyInstruction.__tnInvokeFootprint(params));
 __tnRegisterValidate("PasskeyInstruction", (buffer, params) => PasskeyInstruction.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate("PasskeyInstruction", (buffer) => { const result = PasskeyInstruction.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
-

package/src/passkey-manager/encoding.ts

@@ -1,5 +1,7 @@
 import { hexToBytes as sharedHexToBytes } from '@thru/sdk/helpers';
 
+export { bytesEqual, compareBytes, uniqueAccounts } from '../helpers/bytes';
+
 export function arrayBufferToBase64Url(buffer: ArrayBuffer | SharedArrayBuffer): string {
   const bytes = new Uint8Array(buffer);
   let base64 = '';
@@ -57,29 +59,3 @@ export function bytesToHex(bytes: Uint8Array): string {
 export function hexToBytes(hex: string): Uint8Array {
   return sharedHexToBytes(hex);
 }
-
-export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false;
-  }
-  return true;
-}
-
-export function compareBytes(a: Uint8Array, b: Uint8Array): number {
-  const len = Math.min(a.length, b.length);
-  for (let i = 0; i < len; i++) {
-    if (a[i] !== b[i]) return a[i] - b[i];
-  }
-  return a.length - b.length;
-}
-
-export function uniqueAccounts(accounts: Uint8Array[]): Uint8Array[] {
-  const unique: Uint8Array[] = [];
-  for (const account of accounts) {
-    if (!unique.some((candidate) => bytesEqual(candidate, account))) {
-      unique.push(account);
-    }
-  }
-  return unique;
-}

package/src/token/abi/thru/blockchain/state_proof/types.ts

@@ -32,6 +32,12 @@ type __TnIrNode =
       readonly op: "call";
       readonly typeName: string;
       readonly args: readonly { readonly name: string; readonly source: string }[];
+    }
+  | {
+      readonly op: "sumOverArray";
+      readonly count: __TnIrNode;
+      readonly elementTypeName: string;
+      readonly fieldName: string;
     };
 
 type __TnIrContext = {
@@ -40,7 +46,12 @@ type __TnIrContext = {
   typeName?: string;
 };
 
-type __TnValidateResult = { ok: boolean; code?: string; consumed?: bigint };
+type __TnValidateResult = {
+  ok: boolean;
+  code?: string;
+  consumed?: bigint;
+  params?: Record<string, bigint>;
+};
 type __TnEvalResult =
   | { ok: true; value: bigint }
   | { ok: false; code: string };
@@ -517,6 +528,10 @@ const __tnValidateRegistry: Record<
   string,
   (buffer: Uint8Array, params: Record<string, bigint>) => __TnValidateResult
 > = {};
+const __tnDynamicValidateRegistry: Record<
+  string,
+  (buffer: Uint8Array) => __TnValidateResult
+> = {};
 
 function __tnRegisterFootprint(
   typeName: string,
@@ -532,6 +547,13 @@ function __tnRegisterValidate(
   __tnValidateRegistry[typeName] = fn;
 }
 
+function __tnRegisterDynamicValidate(
+  typeName: string,
+  fn: (buffer: Uint8Array) => __TnValidateResult
+): void {
+  __tnDynamicValidateRegistry[typeName] = fn;
+}
+
 function __tnInvokeFootprint(
   typeName: string,
   params: Record<string, bigint>
@@ -551,8 +573,17 @@ function __tnInvokeValidate(
   return fn(buffer, params);
 }
 
+function __tnInvokeDynamicValidate(
+  typeName: string,
+  buffer: Uint8Array
+): __TnValidateResult {
+  const fn = __tnDynamicValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
+
 function __tnEvalFootprint(node: __TnIrNode, ctx: __TnIrContext): bigint {
-  return __tnEvalIrNode(node, ctx);
+  return __tnEvalIrNode(node, ctx, __tnToBigInt(0));
 }
 
 function __tnTryEvalFootprint(
@@ -567,7 +598,7 @@ function __tnTryEvalIr(
   ctx: __TnIrContext
 ): __TnEvalResult {
   try {
-    return { ok: true, value: __tnEvalIrNode(node, ctx) };
+    return { ok: true, value: __tnEvalIrNode(node, ctx, __tnToBigInt(0)) };
   } catch (err) {
     return { ok: false, code: __tnNormalizeIrError(err) };
   }
@@ -598,7 +629,11 @@ function __tnValidateIrTree(
   return { ok: true, consumed: required };
 }
 
-function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
+function __tnEvalIrNode(
+  node: __TnIrNode,
+  ctx: __TnIrContext,
+  baseOffset: bigint
+): bigint {
   switch (node.op) {
     case "zero":
       return __tnToBigInt(0);
@@ -616,17 +651,22 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       return val;
     }
     case "add":
-      return __tnCheckedAdd(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
-      );
+      {
+        const left = __tnEvalIrNode(node.left, ctx, baseOffset);
+        const right = __tnEvalIrNode(
+          node.right,
+          ctx,
+          __tnCheckedAdd(baseOffset, left)
+        );
+        return __tnCheckedAdd(left, right);
+      }
     case "mul":
       return __tnCheckedMul(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
+        __tnEvalIrNode(node.left, ctx, baseOffset),
+        __tnEvalIrNode(node.right, ctx, baseOffset)
       );
     case "align":
-      return __tnAlign(__tnEvalIrNode(node.node, ctx), node.alignment);
+      return __tnAlign(__tnEvalIrNode(node.node, ctx, baseOffset), node.alignment);
     case "switch": {
       const tagVal = ctx.params[node.tag];
       if (tagVal === undefined) {
@@ -639,10 +679,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       const tagNumber = Number(tagVal);
       for (const caseNode of node.cases) {
         if (caseNode.value === tagNumber) {
-          return __tnEvalIrNode(caseNode.node, ctx);
+          return __tnEvalIrNode(caseNode.node, ctx, baseOffset);
         }
       }
-      if (node.default) return __tnEvalIrNode(node.default, ctx);
+      if (node.default) return __tnEvalIrNode(node.default, ctx, baseOffset);
       __tnRaiseIrError(
         "tn.ir.invalid_tag",
         `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
@@ -662,9 +702,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
         nestedParams[arg.name] = val;
       }
       if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber(baseOffset, "IR nested offset");
         const nestedResult = __tnInvokeValidate(
           node.typeName,
-          ctx.buffer,
+          ctx.buffer.subarray(nestedOffset),
           nestedParams
         );
         if (!nestedResult.ok) {
@@ -684,6 +725,36 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       }
       return __tnInvokeFootprint(node.typeName, nestedParams);
     }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber(
+        __tnEvalIrNode(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === undefined) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd(total, result.consumed);
+      }
+      return total;
+    }
     default:
       __tnRaiseIrError(
         "tn.ir.runtime_error",
@@ -718,6 +789,14 @@ function __tnNormalizeIrError(err: unknown): string {
   return "tn.ir.runtime_error";
 }
 
+__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Hash", (buffer) => { const result = Hash.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
+
+__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Pubkey", (buffer) => { const result = Pubkey.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
+
 /* ----- TYPE DEFINITION FOR StateProofHeader ----- */
 
 const __tn_ir_StateProofHeader = {
@@ -833,9 +912,6 @@ export class StateProofHeader {
 
 }
 
-__tnRegisterFootprint("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
-__tnRegisterValidate("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
-
 export class StateProofHeaderBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -845,7 +921,7 @@ export class StateProofHeaderBuilder {
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
 
-  set_type_slot(value: number): this {
+  set_type_slot(value: bigint): this {
     const cast = __tnToBigInt(value);
     this.view.setBigUint64(0, cast, true);
     return this;
@@ -874,6 +950,10 @@ export class StateProofHeaderBuilder {
   }
 }
 
+__tnRegisterFootprint("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
+__tnRegisterValidate("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("StateProofHeader", (buffer) => { const result = StateProofHeader.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });
+
 /* ----- TYPE DEFINITION FOR StateProof ----- */
 
 const __tn_ir_StateProof = {
@@ -1548,9 +1628,6 @@ export namespace StateProof {
   }
 }
 
-__tnRegisterFootprint("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
-__tnRegisterValidate("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
-
 export class StateProofBuilder {
   private __tnPrefixBuffer: Uint8Array;
   private __tnPrefixView: DataView;
@@ -1665,3 +1742,6 @@ export class StateProofBuilder {
   }
 }
 
+__tnRegisterFootprint("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
+__tnRegisterValidate("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("StateProof", (buffer) => { const result = StateProof.validate(buffer); const params = (result as { params?: Record<string, bigint> }).params; return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed), params }; });