@cofhe/abi 0.6.0 → 0.7.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { EncryptedBoolInput, EncryptedUint8Input, EncryptedUint16Input, EncryptedUint32Input, EncryptedUint64Input, EncryptedUint128Input, EncryptedAddressInput, FheTypes, Primitive, LiteralToPrimitive, EncryptedItemInput, EncryptableBool, EncryptableUint8, EncryptableUint16, EncryptableUint32, EncryptableUint64, EncryptableUint128, EncryptableAddress, EncryptableItem } from '@cofhe/sdk';
+import { ExternalBoolHash, ExternalUint8Hash, ExternalUint16Hash, ExternalUint32Hash, ExternalUint64Hash, ExternalUint128Hash, ExternalAddressHash, FheTypes, AnyExternalHash, EncryptableBool, EncryptableUint8, EncryptableUint16, EncryptableUint32, EncryptableUint64, EncryptableUint128, EncryptableAddress, Primitive, LiteralToPrimitive, EncryptableItem } from '@cofhe/sdk';
 import { Abi, AbiFunction, ExtractAbiFunction, AbiParametersToPrimitiveTypes, AbiParameter, AbiType, SolidityTuple, SolidityArray, SolidityFixedArrayRange, ResolvedRegister, Address, AbiParameterKind, AbiTypeToPrimitiveType, SolidityFixedArraySizeLookup } from 'abitype';
 export { Abi } from 'abitype';
 
@@ -101,13 +101,13 @@ type EncryptedReturnTypeByUtype<U extends FheTypes> = Extract<EncryptedReturnTyp
     utype: U;
 }>;
 type FhenixInternalTypeMap = {
-    'struct InEbool': EncryptedBoolInput;
-    'struct InEuint8': EncryptedUint8Input;
-    'struct InEuint16': EncryptedUint16Input;
-    'struct InEuint32': EncryptedUint32Input;
-    'struct InEuint64': EncryptedUint64Input;
-    'struct InEuint128': EncryptedUint128Input;
-    'struct InEaddress': EncryptedAddressInput;
+    externalEbool: ExternalBoolHash;
+    externalEuint8: ExternalUint8Hash;
+    externalEuint16: ExternalUint16Hash;
+    externalEuint32: ExternalUint32Hash;
+    externalEuint64: ExternalUint64Hash;
+    externalEuint128: ExternalUint128Hash;
+    externalEaddress: ExternalAddressHash;
     ebool: EBool;
     euint8: EUint8;
     euint16: EUint16;
@@ -149,11 +149,40 @@ type CofheAbiArrayToPrimitiveType<abiParameter extends AbiParameter | {
 }>, abiParameterKind>[];
 
 type CofheInputArgs<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = GetArgs<abi, functionName>['args'];
-type EncryptedInputToInputMap<E extends EncryptedItemInput> = E extends EncryptedBoolInput ? EncryptableBool['data'] : E extends EncryptedUint8Input ? EncryptableUint8['data'] : E extends EncryptedUint16Input ? EncryptableUint16['data'] : E extends EncryptedUint32Input ? EncryptableUint32['data'] : E extends EncryptedUint64Input ? EncryptableUint64['data'] : E extends EncryptedUint128Input ? EncryptableUint128['data'] : E extends EncryptedAddressInput ? EncryptableAddress['data'] : never;
-type EncryptedInputsToInputs<T> = T extends Primitive ? LiteralToPrimitive<T> : T extends EncryptedItemInput ? EncryptedInputToInputMap<T> : {
+type ExternalHashToInputMap<E extends AnyExternalHash> = E extends ExternalBoolHash ? EncryptableBool['data'] : E extends ExternalUint8Hash ? EncryptableUint8['data'] : E extends ExternalUint16Hash ? EncryptableUint16['data'] : E extends ExternalUint32Hash ? EncryptableUint32['data'] : E extends ExternalUint64Hash ? EncryptableUint64['data'] : E extends ExternalUint128Hash ? EncryptableUint128['data'] : E extends ExternalAddressHash ? EncryptableAddress['data'] : never;
+type EncryptedInputsToInputs<T> = T extends AnyExternalHash ? ExternalHashToInputMap<T> : T extends Primitive ? LiteralToPrimitive<T> : {
     [K in keyof T]: EncryptedInputsToInputs<T[K]>;
 };
-type CofheInputArgsPreTransform<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = EncryptedInputsToInputs<CofheInputArgs<abi, functionName>>;
+/**
+ * Drops the batch-signature argument from an args tuple.
+ *
+ * The signature slot is the first non-`external*` parameter that follows the contiguous run of
+ * `external*` parameters - `FHE.asEuintXX(hash, proof)` is a pair, so the proof sits with the
+ * hashes it authenticates rather than at the end of the parameter list. Walks the ABI parameters
+ * and the args tuple in lockstep and elides the arg at that position.
+ */
+type DropSignatureSlotTuple<params extends readonly unknown[], args extends readonly unknown[], afterExternalRun extends boolean = false> = params extends readonly [infer P, ...infer PRest extends readonly unknown[]] ? args extends readonly [infer A, ...infer ARest extends readonly unknown[]] ? P extends AbiParameter ? ParamHasExternalInput<P> extends true ? readonly [A, ...DropSignatureSlotTuple<PRest, ARest, true>] : afterExternalRun extends true ? DropSignatureSlotTuple<PRest, ARest, false> : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, false>] : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, afterExternalRun>] : readonly [] : args;
+/** Non-tuple args (e.g. `undefined`) pass through unchanged, as the previous `DropLast` did. */
+type DropSignatureSlot<params extends readonly unknown[], args> = args extends readonly unknown[] ? DropSignatureSlotTuple<params, args> : args;
+declare const EXTERNAL_INPUT_INTERNAL_TYPES: readonly ["externalEbool", "externalEuint8", "externalEuint16", "externalEuint32", "externalEuint64", "externalEuint128", "externalEaddress"];
+type ExternalInputInternalType = (typeof EXTERNAL_INPUT_INTERNAL_TYPES)[number];
+/** Type-level: does this ABI parameter carry (or, if a tuple, recursively contain) an `external*` input? */
+type ParamHasExternalInput<param extends AbiParameter> = MaybeExtractArrayParameterType<param['internalType']> extends [infer head extends string, any] ? head extends ExternalInputInternalType ? true : false : param['internalType'] extends ExternalInputInternalType ? true : param extends {
+    type: 'tuple';
+    components: infer components extends readonly AbiParameter[];
+} ? ParamsHaveExternalInput<components> : false;
+type ParamsHaveExternalInput<params extends readonly AbiParameter[]> = params extends readonly [
+    infer Head extends AbiParameter,
+    ...infer Rest extends readonly AbiParameter[]
+] ? ParamHasExternalInput<Head> extends true ? true : ParamsHaveExternalInput<Rest> : false;
+/**
+ * Pre-transform args for a function ABI: the raw plain values a caller supplies before encryption.
+ *
+ * If the function has one or more `external*` (encrypted) inputs, the plain `bytes` parameter
+ * immediately following them is the shared batch signature slot - the caller never supplies it
+ * directly (the SDK injects it after encryption), so it's dropped from this type entirely.
+ */
+type CofheInputArgsPreTransform<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string, abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction> = EncryptedInputsToInputs<ParamsHaveExternalInput<abiFunction['inputs']> extends true ? DropSignatureSlot<abiFunction['inputs'], CofheInputArgs<abi, functionName>> : CofheInputArgs<abi, functionName>>;
 type GetArgs<abi extends Abi | readonly unknown[] = Abi, // `readonly unknown[]` allows for non-const asserted types
 functionName extends string = string, args extends readonly unknown[] | undefined = readonly [], abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction, primitiveTypes = CofheAbiParametersToPrimitiveTypes<abiFunction['inputs']>, args_ = primitiveTypes | (abi extends Abi ? args extends primitiveTypes ? primitiveTypes extends args ? ReadonlyWiden<args> : never : never : never) | (Abi extends abi ? readonly unknown[] : never)> = MaybePartialBy<{
     args: args_;
@@ -164,14 +193,16 @@ functionName extends string = string, args extends readonly unknown[] | undefine
  *
  * @param abi - The ABI containing the function definition
  * @param functionName - Name of the function
- * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values)
- * @returns Array of EncryptableItem objects ready for encryption
+ * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values;
+ *   if the function has `external*` inputs, the trailing batch-signature slot is NOT included)
+ * @returns Array of EncryptableItem objects ready for encryption, in ABI parameter order
  */
 declare function extractEncryptableValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>): EncryptableItem[];
 /**
  * Re-inserts encrypted values back into function arguments based on the ABI.
- * Takes the extracted values (now encrypted) and the original args structure, and replaces
- * the encryptable values with their encrypted counterparts.
+ * Takes the batch-verified result (per-input hashes, in order, followed by the single shared
+ * signature) and the original args structure, and produces the final call args: each `external*`
+ * position gets its corresponding hash, and the trailing `bytes` parameter gets the signature.
  *
  * This function mirrors the extraction logic in extractEncryptableValues, ensuring values
  * are inserted in the exact same order and locations where they were extracted.
@@ -179,10 +210,10 @@ declare function extractEncryptableValues<TAbi extends Abi, TFunctionName extend
  * @param abi - The ABI containing the function definition
  * @param functionName - Name of the function
  * @param args - Original function arguments in the format of CofheInputArgsPreTransform
- * @param encryptedValues - Encrypted values in the same order as returned by extractEncryptableValues
+ * @param encryptedResult - `[...hashes, signature]`, as returned by `EncryptInputsBuilder.execute()`
  * @returns Function arguments with encrypted values inserted (format of CofheInputArgs)
  */
-declare function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>, encryptedValues: readonly EncryptedItemInput[]): CofheInputArgs<TAbi, TFunctionName>;
+declare function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>, encryptedResult: readonly `0x${string}`[]): CofheInputArgs<TAbi, TFunctionName>;
 
 type FirstCofheReturnValue<T> = [T] extends [void] ? never : T extends readonly [infer Head, ...(readonly unknown[])] ? Head : T;
 type FheTypeFromCofheReturnValue<T> = T extends {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { EncryptedBoolInput, EncryptedUint8Input, EncryptedUint16Input, EncryptedUint32Input, EncryptedUint64Input, EncryptedUint128Input, EncryptedAddressInput, FheTypes, Primitive, LiteralToPrimitive, EncryptedItemInput, EncryptableBool, EncryptableUint8, EncryptableUint16, EncryptableUint32, EncryptableUint64, EncryptableUint128, EncryptableAddress, EncryptableItem } from '@cofhe/sdk';
+import { ExternalBoolHash, ExternalUint8Hash, ExternalUint16Hash, ExternalUint32Hash, ExternalUint64Hash, ExternalUint128Hash, ExternalAddressHash, FheTypes, AnyExternalHash, EncryptableBool, EncryptableUint8, EncryptableUint16, EncryptableUint32, EncryptableUint64, EncryptableUint128, EncryptableAddress, Primitive, LiteralToPrimitive, EncryptableItem } from '@cofhe/sdk';
 import { Abi, AbiFunction, ExtractAbiFunction, AbiParametersToPrimitiveTypes, AbiParameter, AbiType, SolidityTuple, SolidityArray, SolidityFixedArrayRange, ResolvedRegister, Address, AbiParameterKind, AbiTypeToPrimitiveType, SolidityFixedArraySizeLookup } from 'abitype';
 export { Abi } from 'abitype';
 
@@ -101,13 +101,13 @@ type EncryptedReturnTypeByUtype<U extends FheTypes> = Extract<EncryptedReturnTyp
     utype: U;
 }>;
 type FhenixInternalTypeMap = {
-    'struct InEbool': EncryptedBoolInput;
-    'struct InEuint8': EncryptedUint8Input;
-    'struct InEuint16': EncryptedUint16Input;
-    'struct InEuint32': EncryptedUint32Input;
-    'struct InEuint64': EncryptedUint64Input;
-    'struct InEuint128': EncryptedUint128Input;
-    'struct InEaddress': EncryptedAddressInput;
+    externalEbool: ExternalBoolHash;
+    externalEuint8: ExternalUint8Hash;
+    externalEuint16: ExternalUint16Hash;
+    externalEuint32: ExternalUint32Hash;
+    externalEuint64: ExternalUint64Hash;
+    externalEuint128: ExternalUint128Hash;
+    externalEaddress: ExternalAddressHash;
     ebool: EBool;
     euint8: EUint8;
     euint16: EUint16;
@@ -149,11 +149,40 @@ type CofheAbiArrayToPrimitiveType<abiParameter extends AbiParameter | {
 }>, abiParameterKind>[];
 
 type CofheInputArgs<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = GetArgs<abi, functionName>['args'];
-type EncryptedInputToInputMap<E extends EncryptedItemInput> = E extends EncryptedBoolInput ? EncryptableBool['data'] : E extends EncryptedUint8Input ? EncryptableUint8['data'] : E extends EncryptedUint16Input ? EncryptableUint16['data'] : E extends EncryptedUint32Input ? EncryptableUint32['data'] : E extends EncryptedUint64Input ? EncryptableUint64['data'] : E extends EncryptedUint128Input ? EncryptableUint128['data'] : E extends EncryptedAddressInput ? EncryptableAddress['data'] : never;
-type EncryptedInputsToInputs<T> = T extends Primitive ? LiteralToPrimitive<T> : T extends EncryptedItemInput ? EncryptedInputToInputMap<T> : {
+type ExternalHashToInputMap<E extends AnyExternalHash> = E extends ExternalBoolHash ? EncryptableBool['data'] : E extends ExternalUint8Hash ? EncryptableUint8['data'] : E extends ExternalUint16Hash ? EncryptableUint16['data'] : E extends ExternalUint32Hash ? EncryptableUint32['data'] : E extends ExternalUint64Hash ? EncryptableUint64['data'] : E extends ExternalUint128Hash ? EncryptableUint128['data'] : E extends ExternalAddressHash ? EncryptableAddress['data'] : never;
+type EncryptedInputsToInputs<T> = T extends AnyExternalHash ? ExternalHashToInputMap<T> : T extends Primitive ? LiteralToPrimitive<T> : {
     [K in keyof T]: EncryptedInputsToInputs<T[K]>;
 };
-type CofheInputArgsPreTransform<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = EncryptedInputsToInputs<CofheInputArgs<abi, functionName>>;
+/**
+ * Drops the batch-signature argument from an args tuple.
+ *
+ * The signature slot is the first non-`external*` parameter that follows the contiguous run of
+ * `external*` parameters - `FHE.asEuintXX(hash, proof)` is a pair, so the proof sits with the
+ * hashes it authenticates rather than at the end of the parameter list. Walks the ABI parameters
+ * and the args tuple in lockstep and elides the arg at that position.
+ */
+type DropSignatureSlotTuple<params extends readonly unknown[], args extends readonly unknown[], afterExternalRun extends boolean = false> = params extends readonly [infer P, ...infer PRest extends readonly unknown[]] ? args extends readonly [infer A, ...infer ARest extends readonly unknown[]] ? P extends AbiParameter ? ParamHasExternalInput<P> extends true ? readonly [A, ...DropSignatureSlotTuple<PRest, ARest, true>] : afterExternalRun extends true ? DropSignatureSlotTuple<PRest, ARest, false> : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, false>] : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, afterExternalRun>] : readonly [] : args;
+/** Non-tuple args (e.g. `undefined`) pass through unchanged, as the previous `DropLast` did. */
+type DropSignatureSlot<params extends readonly unknown[], args> = args extends readonly unknown[] ? DropSignatureSlotTuple<params, args> : args;
+declare const EXTERNAL_INPUT_INTERNAL_TYPES: readonly ["externalEbool", "externalEuint8", "externalEuint16", "externalEuint32", "externalEuint64", "externalEuint128", "externalEaddress"];
+type ExternalInputInternalType = (typeof EXTERNAL_INPUT_INTERNAL_TYPES)[number];
+/** Type-level: does this ABI parameter carry (or, if a tuple, recursively contain) an `external*` input? */
+type ParamHasExternalInput<param extends AbiParameter> = MaybeExtractArrayParameterType<param['internalType']> extends [infer head extends string, any] ? head extends ExternalInputInternalType ? true : false : param['internalType'] extends ExternalInputInternalType ? true : param extends {
+    type: 'tuple';
+    components: infer components extends readonly AbiParameter[];
+} ? ParamsHaveExternalInput<components> : false;
+type ParamsHaveExternalInput<params extends readonly AbiParameter[]> = params extends readonly [
+    infer Head extends AbiParameter,
+    ...infer Rest extends readonly AbiParameter[]
+] ? ParamHasExternalInput<Head> extends true ? true : ParamsHaveExternalInput<Rest> : false;
+/**
+ * Pre-transform args for a function ABI: the raw plain values a caller supplies before encryption.
+ *
+ * If the function has one or more `external*` (encrypted) inputs, the plain `bytes` parameter
+ * immediately following them is the shared batch signature slot - the caller never supplies it
+ * directly (the SDK injects it after encryption), so it's dropped from this type entirely.
+ */
+type CofheInputArgsPreTransform<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string, abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction> = EncryptedInputsToInputs<ParamsHaveExternalInput<abiFunction['inputs']> extends true ? DropSignatureSlot<abiFunction['inputs'], CofheInputArgs<abi, functionName>> : CofheInputArgs<abi, functionName>>;
 type GetArgs<abi extends Abi | readonly unknown[] = Abi, // `readonly unknown[]` allows for non-const asserted types
 functionName extends string = string, args extends readonly unknown[] | undefined = readonly [], abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction, primitiveTypes = CofheAbiParametersToPrimitiveTypes<abiFunction['inputs']>, args_ = primitiveTypes | (abi extends Abi ? args extends primitiveTypes ? primitiveTypes extends args ? ReadonlyWiden<args> : never : never : never) | (Abi extends abi ? readonly unknown[] : never)> = MaybePartialBy<{
     args: args_;
@@ -164,14 +193,16 @@ functionName extends string = string, args extends readonly unknown[] | undefine
  *
  * @param abi - The ABI containing the function definition
  * @param functionName - Name of the function
- * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values)
- * @returns Array of EncryptableItem objects ready for encryption
+ * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values;
+ *   if the function has `external*` inputs, the trailing batch-signature slot is NOT included)
+ * @returns Array of EncryptableItem objects ready for encryption, in ABI parameter order
  */
 declare function extractEncryptableValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>): EncryptableItem[];
 /**
  * Re-inserts encrypted values back into function arguments based on the ABI.
- * Takes the extracted values (now encrypted) and the original args structure, and replaces
- * the encryptable values with their encrypted counterparts.
+ * Takes the batch-verified result (per-input hashes, in order, followed by the single shared
+ * signature) and the original args structure, and produces the final call args: each `external*`
+ * position gets its corresponding hash, and the trailing `bytes` parameter gets the signature.
  *
  * This function mirrors the extraction logic in extractEncryptableValues, ensuring values
  * are inserted in the exact same order and locations where they were extracted.
@@ -179,10 +210,10 @@ declare function extractEncryptableValues<TAbi extends Abi, TFunctionName extend
  * @param abi - The ABI containing the function definition
  * @param functionName - Name of the function
  * @param args - Original function arguments in the format of CofheInputArgsPreTransform
- * @param encryptedValues - Encrypted values in the same order as returned by extractEncryptableValues
+ * @param encryptedResult - `[...hashes, signature]`, as returned by `EncryptInputsBuilder.execute()`
  * @returns Function arguments with encrypted values inserted (format of CofheInputArgs)
  */
-declare function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>, encryptedValues: readonly EncryptedItemInput[]): CofheInputArgs<TAbi, TFunctionName>;
+declare function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(abi: TAbi, functionName: TFunctionName, args: CofheInputArgsPreTransform<TAbi, TFunctionName>, encryptedResult: readonly `0x${string}`[]): CofheInputArgs<TAbi, TFunctionName>;
 
 type FirstCofheReturnValue<T> = [T] extends [void] ? never : T extends readonly [infer Head, ...(readonly unknown[])] ? Head : T;
 type FheTypeFromCofheReturnValue<T> = T extends {

package/dist/index.js

@@ -27,46 +27,54 @@ function getAbiFunction(abi, functionName) {
 }
 
 // src/encryptedInputs.ts
-var ENCRYPTED_INPUT_INTERNAL_TYPES = [
-  "struct InEbool",
-  "struct InEuint8",
-  "struct InEuint16",
-  "struct InEuint32",
-  "struct InEuint64",
-  "struct InEuint128",
-  "struct InEaddress"
+var EXTERNAL_INPUT_INTERNAL_TYPES = [
+  "externalEbool",
+  "externalEuint8",
+  "externalEuint16",
+  "externalEuint32",
+  "externalEuint64",
+  "externalEuint128",
+  "externalEaddress"
 ];
-function transformSingleEncryptedInputToEncryptable(internalType, data) {
+function internalTypeIsExternalInput(internalType) {
+  return EXTERNAL_INPUT_INTERNAL_TYPES.includes(internalType);
+}
+function paramHasExternalInput(param) {
+  const [internalTypeHead] = extractArrayParameterType(param.internalType);
+  if (internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) return true;
+  if ("components" in param && Array.isArray(param.components)) {
+    return param.components.some((component) => paramHasExternalInput(component));
+  }
+  return false;
+}
+function transformSingleExternalToEncryptable(internalType, data) {
   switch (internalType) {
-    case "struct InEbool":
+    case "externalEbool":
       return Encryptable.bool(data);
-    case "struct InEuint8":
+    case "externalEuint8":
       return Encryptable.uint8(data);
-    case "struct InEuint16":
+    case "externalEuint16":
       return Encryptable.uint16(data);
-    case "struct InEuint32":
+    case "externalEuint32":
       return Encryptable.uint32(data);
-    case "struct InEuint64":
+    case "externalEuint64":
       return Encryptable.uint64(data);
-    case "struct InEuint128":
+    case "externalEuint128":
       return Encryptable.uint128(data);
-    case "struct InEaddress":
+    case "externalEaddress":
       return Encryptable.address(data);
     default:
-      throw new Error(`Unknown encrypted input type: ${internalType}`);
+      throw new Error(`Unknown external input type: ${internalType}`);
   }
 }
-function transformArrayOfEncryptedInputsToEncryptables(internalType, size, data) {
+function transformArrayOfExternalsToEncryptables(internalType, size, data) {
   if (!Array.isArray(data)) {
     throw new Error("Data must be an array");
   }
   if (size != null && size !== "" && parseInt(size) !== data.length) {
     throw new Error(`Array size mismatch: ${size} !== ${data.length}`);
   }
-  return data.map((item) => transformSingleEncryptedInputToEncryptable(internalType, item));
-}
-function internalTypeIsEncryptedInput(internalType) {
-  return ENCRYPTED_INPUT_INTERNAL_TYPES.includes(internalType);
+  return data.map((item) => transformSingleExternalToEncryptable(internalType, item));
 }
 function extractEncryptableValues(abi, functionName, args) {
   const abiFunction = getAbiFunction(abi, functionName);
@@ -77,21 +85,22 @@ function extractEncryptableValues(abi, functionName, args) {
   if (!Array.isArray(args)) {
     throw new Error("Arguments must be an array");
   }
+  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));
+  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);
   const encryptableItems = [];
   function processParameter(param, value) {
     const [typeHead, typeSize] = extractArrayParameterType(param.type);
     const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
-    if (typeHead === "tuple" && typeSize == null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
-      const encryptable = transformSingleEncryptedInputToEncryptable(internalTypeHead, value);
-      encryptableItems.push(encryptable);
+    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      encryptableItems.push(transformSingleExternalToEncryptable(internalTypeHead, value));
       return;
     }
-    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
-      const encryptables = transformArrayOfEncryptedInputsToEncryptables(internalTypeHead, typeSize, value);
+    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      const encryptables = transformArrayOfExternalsToEncryptables(internalTypeHead, typeSize, value);
       encryptableItems.push(...encryptables);
       return;
     }
-    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+    if (typeHead === "tuple") {
       if ("components" in param && Array.isArray(param.components)) {
         param.components.forEach((component) => {
           processParameter(component, value[component.name]);
@@ -101,16 +110,41 @@ function extractEncryptableValues(abi, functionName, args) {
     }
     return;
   }
+  let argIndex = 0;
   inputs.forEach((input, index) => {
-    const arg = args[index];
+    if (index === signatureSlotIndex) return;
+    const arg = args[argIndex];
     if (arg == null) {
-      throw new Error(`Argument ${index} is undefined`);
+      throw new Error(`Argument ${argIndex} is undefined`);
     }
+    argIndex++;
     processParameter(input, arg);
   });
   return encryptableItems;
 }
-function insertEncryptedValues(abi, functionName, args, encryptedValues) {
+function findSignatureSlotIndex(inputs, hasExternalInputs, functionName) {
+  if (!hasExternalInputs) return -1;
+  const externalIndices = inputs.reduce((acc, input, index) => {
+    if (paramHasExternalInput(input)) acc.push(index);
+    return acc;
+  }, []);
+  const first = externalIndices[0];
+  const last = externalIndices[externalIndices.length - 1];
+  if (last - first + 1 !== externalIndices.length) {
+    throw new Error(
+      `Function ${functionName} has encrypted (external*) inputs at non-adjacent positions (${externalIndices.join(", ")}). They share one batch signature, so they must be contiguous with the 'bytes' signature parameter immediately after them`
+    );
+  }
+  const slotIndex = last + 1;
+  const slot = inputs[slotIndex];
+  if (slot?.type !== "bytes") {
+    throw new Error(
+      `Function ${functionName} has encrypted (external*) inputs, so the parameter immediately after them must be a plain 'bytes' parameter to receive the shared batch signature - found '${slot?.type ?? "nothing"}' at position ${slotIndex} instead`
+    );
+  }
+  return slotIndex;
+}
+function insertEncryptedValues(abi, functionName, args, encryptedResult) {
   const abiFunction = getAbiFunction(abi, functionName);
   const inputs = abiFunction?.inputs;
   if (abiFunction == null || inputs == null) {
@@ -119,35 +153,37 @@ function insertEncryptedValues(abi, functionName, args, encryptedValues) {
   if (!Array.isArray(args)) {
     throw new Error("Arguments must be an array");
   }
-  let encryptedIndex = 0;
+  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));
+  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);
+  const hashes = hasExternalInputs ? encryptedResult.slice(0, -1) : [];
+  const signature = hasExternalInputs ? encryptedResult[encryptedResult.length - 1] : void 0;
+  let hashIndex = 0;
   function processParameter(param, value) {
     const [typeHead, typeSize] = extractArrayParameterType(param.type);
-    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
-    if (typeHead === "tuple" && typeSize == null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
-      if (encryptedIndex >= encryptedValues.length) {
-        throw new Error(
-          `Not enough encrypted values: expected at least ${encryptedIndex + 1}, got ${encryptedValues.length}`
-        );
+    const [internalTypeHead] = extractArrayParameterType(param.internalType);
+    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      if (hashIndex >= hashes.length) {
+        throw new Error(`Not enough encrypted hashes: expected at least ${hashIndex + 1}, got ${hashes.length}`);
       }
-      const encryptedValue = encryptedValues[encryptedIndex];
-      encryptedIndex++;
-      return encryptedValue;
+      const hash = hashes[hashIndex];
+      hashIndex++;
+      return hash;
     }
-    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
       const arrayLength = Array.isArray(value) ? value.length : 0;
       if (arrayLength === 0) {
         return [];
       }
-      if (encryptedIndex + arrayLength > encryptedValues.length) {
+      if (hashIndex + arrayLength > hashes.length) {
         throw new Error(
-          `Not enough encrypted values: expected at least ${encryptedIndex + arrayLength}, got ${encryptedValues.length}`
+          `Not enough encrypted hashes: expected at least ${hashIndex + arrayLength}, got ${hashes.length}`
         );
       }
-      const encryptedArray = encryptedValues.slice(encryptedIndex, encryptedIndex + arrayLength);
-      encryptedIndex += arrayLength;
-      return encryptedArray;
+      const hashArray = hashes.slice(hashIndex, hashIndex + arrayLength);
+      hashIndex += arrayLength;
+      return hashArray;
     }
-    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+    if (typeHead === "tuple") {
       if ("components" in param && Array.isArray(param.components)) {
         const valueObj = value;
         const result2 = {};
@@ -166,17 +202,20 @@ function insertEncryptedValues(abi, functionName, args, encryptedValues) {
     }
     return value;
   }
+  let argIndex = 0;
   const result = inputs.map((input, index) => {
-    const arg = args[index];
+    if (index === signatureSlotIndex) {
+      return signature;
+    }
+    const arg = args[argIndex];
     if (arg == null) {
-      throw new Error(`Argument ${index} is undefined`);
+      throw new Error(`Argument ${argIndex} is undefined`);
     }
+    argIndex++;
     return processParameter(input, arg);
   });
-  if (encryptedIndex !== encryptedValues.length) {
-    throw new Error(
-      `Mismatch in encrypted values count: used ${encryptedIndex}, but provided ${encryptedValues.length}`
-    );
+  if (hashIndex !== hashes.length) {
+    throw new Error(`Mismatch in encrypted hashes count: used ${hashIndex}, but provided ${hashes.length}`);
   }
   return result;
 }