@keetanetwork/keetanet-client 0.14.11 → 0.14.13

package/client/index-browser.js

@@ -113844,7 +113844,8 @@ var client_schema = /*#__PURE__*/new WeakMap();
  * - {@link ValidateASN1.IsNull}
  *
  * More complex types are defined as:
- * - Choice: `{ choice: [ schema1, schema2, ... ] }`
+ * - Choice (named): `{ choice: { name1: schema1, name2: schema2, ... } }` - Converts to `{ name1: value }` or `{ name2: value }`
+ * - Choice (legacy array): `{ choice: [ schema1, schema2, ... ] }` - Converts to union type (ambiguous for re-encoding)
  * - Sequence of: `{ sequenceOf: schema }`
  * - Optional: `{ optional: schema }`
  * - Context Tag: `{ type: 'context'; kind: 'implicit' | 'explicit'; contains: schema; value: number }`
@@ -114197,6 +114198,7 @@ class client_ValidateASN1 {
             {
               const outputStruct = {
                 type: 'struct',
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
                 fieldNames: schema.fieldNames,
                 contains: {}
               };
@@ -114228,6 +114230,49 @@ class client_ValidateASN1 {
             client_assertNever(schema);
         }
       } else if ('choice' in schema) {
+        // Handle named choices: { choice: { a: schema1, b: schema2 } }
+        if (!Array.isArray(schema.choice)) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          const choiceObj = schema.choice;
+
+          // For context tags, match by value and kind
+          if (client_isASN1ContextTag(input)) {
+            const inputAsChoice = input;
+            for (const choiceName in choiceObj) {
+              const choice = choiceObj[choiceName];
+              if (choice === undefined) {
+                continue;
+              }
+              if (!client_isASN1ContextTag(choice)) {
+                continue;
+              }
+              if (choice.value !== inputAsChoice.value) {
+                continue;
+              }
+              if (choice.kind !== inputAsChoice.kind) {
+                continue;
+              }
+              return client_ValidateASN1.againstSchema(input, choice);
+            }
+            throw new Error('No valid choice found');
+          }
+
+          // Try each choice
+          for (const choiceName in choiceObj) {
+            const choice = choiceObj[choiceName];
+            if (choice === undefined) {
+              continue;
+            }
+            try {
+              return client_ValidateASN1.againstSchema(input, choice);
+            } catch (_ignored_checkError) {
+              /* Ignored error */
+            }
+          }
+          throw new Error('No valid choice found');
+        }
+
+        // Handle array choices (legacy)
         if (client_isASN1ContextTag(input)) {
           const inputAsChoice = input;
           const matchingSchema = schema.choice.find(function (choice) {
@@ -114249,7 +114294,6 @@ class client_ValidateASN1 {
         }
         for (const choice of schema.choice) {
           try {
-            // @ts-ignore
             return client_ValidateASN1.againstSchema(input, choice);
           } catch (_ignored_checkError) {
             /* Ignored error */
@@ -114339,6 +114383,578 @@ class client_ValidateASN1 {
   validate(input) {
     return client_ValidateASN1.againstSchema(input, client_asn1_classPrivateFieldGet(client_schema, this));
   }
+
+  /**
+   * Convert an ASN.1 object to a JavaScript object (including primitives)
+   * based on the schema.
+   *
+   * Converts ASN1 objects to plain JavaScript objects according to the schema:
+   * - Structs are converted to plain objects with field names as keys
+   * - For ambiguous types (IsAnyString, IsAnyDate), returns ASN.1-like objects: { type: 'string', kind: 'utf8', value: 'text' }
+   * - Arrays/sequences are preserved as arrays
+   * - Primitive types (bigint, string, boolean, null, Buffer, Date) are preserved
+   *
+   * Example schema: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: ValidateASN1.IsAnyString, age: ValidateASN1.IsInteger } }
+   * Input: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n } }
+   * Output: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n }
+   */
+  toJavaScriptObject(input) {
+    this.validate(input);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return client_ValidateASN1.toPlainObject(input, client_asn1_classPrivateFieldGet(client_schema, this));
+  }
+
+  /**
+   * Convert a plain JavaScript object back to an ASN.1 object based on the schema.
+   *
+   * Converts plain JavaScript objects back to ASN1 representation according to the schema:
+   * - Plain objects with field names are converted to ASN1Struct
+   * - For ambiguous schemas, recognizes ASN.1-like objects: { type: 'string', kind: 'utf8', value: 'text' }
+   * - Arrays are preserved as sequences
+   * - Primitive types are preserved or wrapped in appropriate ASN1 types
+   *
+   * Example schema: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: ValidateASN1.IsAnyString, age: ValidateASN1.IsInteger } }
+   * Input: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n }
+   * Output: { type: 'struct', fieldNames: ['name', 'age'], contains: { name: { type: 'string', kind: 'utf8', value: 'John Doe' }, age: 30n } }
+   */
+  fromJavaScriptObject(input) {
+    const retval = client_ValidateASN1.fromPlainObject(input, client_asn1_classPrivateFieldGet(client_schema, this));
+    this.validate(retval);
+    return retval;
+  }
+
+  /**
+   * Convert an ASN.1 object to a plain JavaScript object based on a schema
+   */
+  static toPlainObject(input, schemaIn) {
+    let schema = schemaIn;
+    if (typeof schema === 'function') {
+      schema = schema();
+    }
+
+    // Handle choice schemas first (before primitive checks)
+    // This ensures named choices wrap their values correctly
+    if (typeof schema === 'object' && schema !== null && 'choice' in schema) {
+      // Handle named choices: { choice: { a: schema1, b: schema2 } }
+      if (!Array.isArray(schema.choice)) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const choiceObj = schema.choice;
+        for (const choiceName in choiceObj) {
+          const choiceSchema = choiceObj[choiceName];
+          if (choiceSchema === undefined) {
+            continue;
+          }
+          try {
+            // Validate that the input matches this choice schema
+            client_ValidateASN1.againstSchema(input, choiceSchema);
+            // If validation passes, convert and wrap in named object
+            const converted = client_ValidateASN1.toPlainObject(input, choiceSchema);
+            return {
+              [choiceName]: converted
+            };
+          } catch {
+            // Try next choice
+          }
+        }
+        throw new Error('No valid choice found');
+      }
+
+      // Handle array choices (legacy): { choice: [schema1, schema2] }
+      // For choices, recursively convert the selected choice
+      for (const choice of schema.choice) {
+        try {
+          return client_ValidateASN1.toPlainObject(input, choice);
+        } catch {
+          // Try next choice
+        }
+      }
+      throw new Error('No valid choice found');
+    }
+
+    // Handle primitives that don't need conversion
+    if (typeof input === 'bigint' || typeof input === 'boolean' || input === null || client_isBuffer(input) || client_util.types.isDate(input)) {
+      return input;
+    }
+
+    // Handle plain strings
+    if (typeof input === 'string') {
+      return input;
+    }
+
+    // Handle basic schema types
+    if (typeof schema === 'symbol') {
+      switch (schema) {
+        case client_ValidateASN1.IsInteger:
+        case client_ValidateASN1.IsBoolean:
+        case client_ValidateASN1.IsNull:
+        case client_ValidateASN1.IsOctetString:
+        case client_ValidateASN1.IsString:
+        case client_ValidateASN1.IsDate:
+          return input;
+        case client_ValidateASN1.IsAnyString:
+          if (client_isASN1String(input)) {
+            // For ambiguous schemas, return ASN.1-like object
+            return {
+              type: 'string',
+              kind: input.kind,
+              value: input.value
+            };
+          }
+          return input;
+        case client_ValidateASN1.IsAnyDate:
+          if (client_isASN1Date(input)) {
+            // For ambiguous schemas, return ASN.1-like object
+            return {
+              type: 'date',
+              kind: input.kind,
+              value: input.date
+            };
+          }
+          return input;
+        case client_ValidateASN1.IsBitString:
+          if (client_isASN1BitString(input)) {
+            // Use expanded form to preserve unusedBits information
+            // This distinguishes between bit strings like 111 and 0111
+            return {
+              type: 'bitstring',
+              value: input.value,
+              unusedBits: input.unusedBits
+            };
+          }
+          return input;
+        case client_ValidateASN1.IsOID:
+          if (client_isASN1OID(input)) {
+            return input.oid;
+          }
+          return input;
+        case client_ValidateASN1.IsSet:
+          return input;
+        case client_ValidateASN1.IsAny:
+        case client_ValidateASN1.IsUnknown:
+          return input;
+      }
+    }
+
+    // Handle bigint schema (fixed value)
+    if (typeof schema === 'bigint') {
+      return input;
+    }
+
+    // Handle object schemas
+    if (typeof schema === 'object' && schema !== null) {
+      if ('type' in schema) {
+        switch (schema.type) {
+          case 'struct':
+            {
+              if (!client_isASN1Struct(input)) {
+                throw new Error('Expected ASN1Struct');
+              }
+              const result = {};
+              for (const fieldName of schema.fieldNames) {
+                const fieldValue = input.contains[fieldName];
+                if (fieldValue === undefined) {
+                  continue;
+                }
+                const fieldSchema = schema.contains[fieldName];
+                if (client_isASN1ContextTag(fieldValue)) {
+                  // Context tags are metadata like optional - unwrap them completely
+                  // Need to unwrap optional and get the context tag schema
+                  let contextSchema = fieldSchema;
+                  if (typeof contextSchema === 'object' && contextSchema !== null && 'optional' in contextSchema) {
+                    contextSchema = contextSchema.optional;
+                  }
+
+                  // For implicit context tags with ArrayBuffer, can't convert further
+                  if (fieldValue.kind === 'implicit' && client_util.types.isArrayBuffer(fieldValue.contains)) {
+                    result[fieldName] = fieldValue.contains;
+                  } else if (typeof contextSchema === 'object' && contextSchema !== null && 'type' in contextSchema && contextSchema.type === 'context' && 'contains' in contextSchema) {
+                    // Unwrap the context tag - just convert the inner value
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    result[fieldName] = client_ValidateASN1.toPlainObject(fieldValue.contains, contextSchema.contains);
+                  } else {
+                    // Fallback: convert the inner value with full field schema
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    result[fieldName] = client_ValidateASN1.toPlainObject(fieldValue.contains, fieldSchema);
+                  }
+                } else {
+                  // For all other types (including strings and dates), recursively convert
+                  const plainValue = client_ValidateASN1.toPlainObject(fieldValue, fieldSchema);
+                  result[fieldName] = plainValue;
+                }
+              }
+              return result;
+            }
+          case 'string':
+            if (client_isASN1String(input)) {
+              return input.value;
+            }
+            return input;
+          case 'date':
+            if (client_isASN1Date(input)) {
+              return input.date;
+            }
+            return input;
+          case 'oid':
+            if (client_isASN1OID(input)) {
+              return input.oid;
+            }
+            return input;
+          case 'context':
+            if (client_isASN1ContextTag(input)) {
+              // For implicit context tags with ArrayBuffer, we can't convert further
+              if (input.kind === 'implicit' && client_util.types.isArrayBuffer(input.contains)) {
+                return input.contains;
+              }
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              return client_ValidateASN1.toPlainObject(input.contains, schema.contains);
+            }
+            return input;
+        }
+      }
+      if ('sequenceOf' in schema) {
+        if (!Array.isArray(input)) {
+          throw new Error('Expected array for sequenceOf');
+        }
+        return input.map(item => client_ValidateASN1.toPlainObject(item, schema.sequenceOf));
+      }
+      if ('optional' in schema) {
+        if (input === undefined) {
+          return undefined;
+        }
+        return client_ValidateASN1.toPlainObject(input, schema.optional);
+      }
+      if (Array.isArray(schema)) {
+        if (!Array.isArray(input)) {
+          throw new Error('Expected array');
+        }
+        const result = [];
+        for (let i = 0; i < Math.min(input.length, schema.length); i++) {
+          const item = input[i];
+          if (item === undefined) {
+            result.push(undefined);
+          } else {
+            result.push(client_ValidateASN1.toPlainObject(item, schema[i]));
+          }
+        }
+        return result;
+      }
+    }
+    return input;
+  }
+
+  /**
+   * Convert a plain JavaScript object to an ASN.1 object based on a schema
+   */
+  static fromPlainObject(input, schemaIn) {
+    let schema = schemaIn;
+    if (typeof schema === 'function') {
+      schema = schema();
+    }
+
+    // Handle null/undefined
+    if (input === null || input === undefined) {
+      /* Verify that the schema for this is actually is nullable */
+      let nullable = false;
+      if (schema === client_ValidateASN1.IsNull) {
+        nullable = true;
+      } else if (typeof schema === 'object' && schema !== null) {
+        if ('optional' in schema) {
+          nullable = true;
+        }
+      }
+      if (!nullable) {
+        throw new Error(`Expected non-null value, got ${input}`);
+      }
+
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return input;
+    }
+
+    // For ambiguous schemas (IsAnyString, IsAnyDate), check if input is already in ASN.1-like format
+    // These are objects like { type: 'string', kind: 'utf8', value: 'text' } or { type: 'date', kind: 'general', value: Date }
+    // Also handle expanded bitstring format: { type: 'bitstring', value: Buffer, unusedBits: number }
+    if (typeof input === 'object' && input !== null && !client_isBuffer(input) && !client_util.types.isDate(input) && !Array.isArray(input)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const inputObj = input;
+
+      // Check for string-like format: { type: 'string', kind, value }
+      if (inputObj.type === 'string' && typeof inputObj.kind === 'string' && 'value' in inputObj) {
+        const kind = inputObj.kind;
+        if (kind === 'printable' || kind === 'ia5' || kind === 'utf8') {
+          if (typeof inputObj.value === 'string') {
+            return {
+              type: 'string',
+              kind,
+              value: inputObj.value
+            };
+          }
+        }
+      }
+
+      // Check for date-like format: { type: 'date', kind, value }
+      if (inputObj.type === 'date' && typeof inputObj.kind === 'string' && 'value' in inputObj) {
+        const kind = inputObj.kind;
+        if (kind === 'utc' || kind === 'general') {
+          if (client_util.types.isDate(inputObj.value)) {
+            return {
+              type: 'date',
+              kind,
+              date: inputObj.value
+            };
+          }
+        }
+      }
+
+      // Check for bitstring format: { type: 'bitstring', value, unusedBits }
+      if (inputObj.type === 'bitstring' && 'value' in inputObj && 'unusedBits' in inputObj) {
+        if (client_isBuffer(inputObj.value) && typeof inputObj.unusedBits === 'number') {
+          return {
+            type: 'bitstring',
+            value: inputObj.value,
+            unusedBits: inputObj.unusedBits
+          };
+        }
+      }
+    }
+
+    // Check schema FIRST before doing any primitive handling
+    // This is important for context tags and other wrappers
+
+    // Handle object schemas
+    if (typeof schema === 'object' && schema !== null) {
+      if ('type' in schema) {
+        switch (schema.type) {
+          case 'context':
+            {
+              // Context tags: reconstruct from schema definition (metadata like optional)
+              // Schema has the kind and value, input is the plain value
+              // At this point we know schema.type === 'context', so it must have kind, value, contains
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              const contextTagSchema = schema;
+              return {
+                type: 'context',
+                kind: contextTagSchema.kind,
+                value: contextTagSchema.value,
+                contains: client_ValidateASN1.fromPlainObject(input, contextTagSchema.contains)
+              };
+            }
+          case 'struct':
+            {
+              if (typeof input !== 'object' || input === null) {
+                throw new Error('Expected object for struct');
+              }
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              const inputObj = input;
+              const result = {
+                type: 'struct',
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                fieldNames: schema.fieldNames,
+                contains: {}
+              };
+              for (const fieldName of schema.fieldNames) {
+                const fieldValue = inputObj[fieldName];
+                if (fieldValue === undefined) {
+                  continue;
+                }
+                const fieldSchema = schema.contains[fieldName];
+                result.contains[fieldName] = client_ValidateASN1.fromPlainObject(fieldValue, fieldSchema);
+              }
+              return result;
+            }
+          case 'string':
+            if (typeof input === 'string') {
+              return {
+                type: 'string',
+                kind: schema.kind,
+                value: input
+              };
+            }
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return input;
+          case 'date':
+            if (client_util.types.isDate(input)) {
+              return {
+                type: 'date',
+                kind: schema.kind,
+                date: input
+              };
+            }
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return input;
+          case 'oid':
+            if (typeof input === 'string') {
+              return {
+                type: 'oid',
+                oid: input
+              };
+            }
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return input;
+        }
+      }
+      if ('choice' in schema) {
+        // Handle named choices: { choice: { a: schema1, b: schema2 } }
+        if (!Array.isArray(schema.choice)) {
+          if (typeof input === 'object' && input !== null && !client_isBuffer(input) && !client_util.types.isDate(input)) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const inputObj = input;
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const choiceObj = schema.choice;
+
+            // Find which choice name is present in the input
+            for (const choiceName in choiceObj) {
+              if (choiceName in inputObj) {
+                const choiceSchema = choiceObj[choiceName];
+                if (choiceSchema === undefined) {
+                  continue;
+                }
+                const choiceValue = inputObj[choiceName];
+                return client_ValidateASN1.fromPlainObject(choiceValue, choiceSchema);
+              }
+            }
+          }
+          throw new Error('No valid choice found for input - expected object with one of: ' + Object.keys(schema.choice).join(', '));
+        }
+
+        // Handle array choices (legacy): { choice: [schema1, schema2] }
+        // For choices, try to convert with each choice schema
+        for (const choice of schema.choice) {
+          try {
+            return client_ValidateASN1.fromPlainObject(input, choice);
+          } catch {
+            // Try next choice
+          }
+        }
+        throw new Error('No valid choice found for input');
+      }
+      if ('sequenceOf' in schema) {
+        if (!Array.isArray(input)) {
+          throw new Error('Expected array for sequenceOf');
+        }
+        return input.map(item => client_ValidateASN1.fromPlainObject(item, schema.sequenceOf));
+      }
+      if ('optional' in schema) {
+        return client_ValidateASN1.fromPlainObject(input, schema.optional);
+      }
+      if (Array.isArray(schema)) {
+        if (!Array.isArray(input)) {
+          throw new Error('Expected array');
+        }
+        const result = [];
+        for (let i = 0; i < schema.length; i++) {
+          if (i < input.length && input[i] !== undefined) {
+            result.push(client_ValidateASN1.fromPlainObject(input[i], schema[i]));
+          } else if (client_isASN1ModifierOptional(schema[i])) {
+            result.push(undefined);
+          } else {
+            throw new Error(`Missing required field at index ${i}`);
+          }
+        }
+        return result;
+      }
+    }
+
+    // Handle symbol schemas (basic types)
+    if (typeof schema === 'symbol') {
+      switch (schema) {
+        case client_ValidateASN1.IsInteger:
+        case client_ValidateASN1.IsBoolean:
+        case client_ValidateASN1.IsNull:
+        case client_ValidateASN1.IsDate:
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsOctetString:
+          // OctetString can accept a Buffer directly
+          if (client_isBuffer(input)) {
+            return input;
+          }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsString:
+          if (typeof input === 'string') {
+            return input;
+          }
+          throw new Error('Expected string');
+        case client_ValidateASN1.IsAnyString:
+          if (typeof input === 'string') {
+            // Determine appropriate string kind
+            if (client_isStringValidForKind(input, 'printable')) {
+              return {
+                type: 'string',
+                kind: 'printable',
+                value: input
+              };
+            } else if (client_isStringValidForKind(input, 'ia5')) {
+              return {
+                type: 'string',
+                kind: 'ia5',
+                value: input
+              };
+            } else {
+              return {
+                type: 'string',
+                kind: 'utf8',
+                value: input
+              };
+            }
+          }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsAnyDate:
+          if (client_util.types.isDate(input)) {
+            if (input.getUTCFullYear() < 2050) {
+              return {
+                type: 'date',
+                kind: 'utc',
+                date: input
+              };
+            } else {
+              return {
+                type: 'date',
+                kind: 'general',
+                date: input
+              };
+            }
+          }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsBitString:
+          if (client_isBuffer(input)) {
+            return {
+              type: 'bitstring',
+              value: input,
+              unusedBits: 0
+            };
+          }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsOID:
+          if (typeof input === 'string') {
+            return {
+              type: 'oid',
+              oid: input
+            };
+          }
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+        case client_ValidateASN1.IsSet:
+        case client_ValidateASN1.IsAny:
+        case client_ValidateASN1.IsUnknown:
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          return input;
+      }
+    }
+
+    // Handle bigint schema (fixed value)
+    if (typeof schema === 'bigint') {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return input;
+    }
+
+    // Default: return input as-is
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return input;
+  }
 }
 
 /**
@@ -115397,7 +116013,7 @@ function client_block_toPrimitive(t, r) { if ("object" != typeof t || !t) return
 
 
 const client_BlockErrorType = 'BLOCK';
-const client_BlockErrorCodes = ['INVALID_TYPE', 'INVALID_VERSION', 'NO_MULTIPLE_SET_REP', 'IDENTIFIER_NEED_DEFAULT_PERMISSIONS', 'CANNOT_SEND_NON_TOKEN', 'TOKEN_RECEIVE_DIFFERS', 'ONLY_TOKEN_OP', 'ONLY_IDENTIFIER_OP', 'NO_TOKEN_OP', 'NO_IDENTIFIER_OP', 'INVALID_SIGNER', 'INVALID_PURPOSE_VALIDATION', 'INVALID_MULTISIG_QUORUM', 'INVALID_MULTISIG_SIGNER_DEPTH', 'INVALID_MULTISIG_SIGNER_COUNT', 'INVALID_MULTISIG_SIGNER_DUPLICATE', 'INVALID_CREATE_IDENTIFIER_ARGS', 'NO_MULTISIG_OP', 'IDENTIFIER_INVALID', 'GENERAL_FIELD_INVALID', 'PERMISSIONS_INVALID_DEFAULT', 'PERMISSIONS_INVALID_ENTITY', 'PERMISSIONS_INVALID_PRINCIPAL', 'PERMISSIONS_INVALID_TARGET', 'INVALID_ACCOUNT_TYPE', 'NO_ADMIN_ON_TARGET', 'PREVIOUS_SELF', 'NO_DELEGATE_ADMIN', 'NO_MODIFY_PERMISSION_DUPE', 'CANNOT_FORWARD_TO_SELF', 'EXACT_TRUE_WHEN_FORWARDING', 'CERTIFICATE_SUBJECT_MISMATCH', 'NO_DUPLICATE_CERTIFICATE_OPERATION', 'INTERMEDIATE_CERTIFICATES_ONLY_ADD', 'INVALID_CERTIFICATE_VALUE', 'EXTERNAL_TOO_LONG', 'EXTERNAL_INVALID', 'EXTERNAL_MISSING', 'SUPPLY_INVALID', 'INVALID_IDEMPOTENT_FORMAT', 'INVALID_IDEMPOTENT_LENGTH'];
+const client_BlockErrorCodes = ['AMOUNT_BELOW_ZERO', 'CANNOT_FORWARD_TO_SELF', 'CANNOT_SEND_NON_TOKEN', 'CERTIFICATE_SUBJECT_MISMATCH', 'EXACT_TRUE_WHEN_FORWARDING', 'EXTERNAL_INVALID', 'EXTERNAL_MISSING', 'EXTERNAL_TOO_LONG', 'GENERAL_FIELD_INVALID', 'IDENTIFIER_INVALID', 'IDENTIFIER_NEED_DEFAULT_PERMISSIONS', 'INTERMEDIATE_CERTIFICATES_ONLY_ADD', 'INVALID_ACCOUNT_TYPE', 'INVALID_CERTIFICATE_VALUE', 'INVALID_CREATE_IDENTIFIER_ARGS', 'INVALID_IDEMPOTENT_FORMAT', 'INVALID_IDEMPOTENT_LENGTH', 'INVALID_MULTISIG_QUORUM', 'INVALID_MULTISIG_SIGNER_COUNT', 'INVALID_MULTISIG_SIGNER_DEPTH', 'INVALID_MULTISIG_SIGNER_DUPLICATE', 'INVALID_PURPOSE_VALIDATION', 'INVALID_SIGNATURE', 'INVALID_SIGNER', 'INVALID_TYPE', 'INVALID_VERSION', 'NO_ADMIN_ON_TARGET', 'NO_DELEGATE_ADMIN', 'NO_DUPLICATE_CERTIFICATE_OPERATION', 'NO_IDENTIFIER_OP', 'NO_MODIFY_PERMISSION_DUPE', 'NO_MULTIPLE_SET_REP', 'NO_MULTISIG_OP', 'NO_TOKEN_OP', 'ONLY_IDENTIFIER_OP', 'ONLY_TOKEN_OP', 'PERMISSIONS_INVALID_DEFAULT', 'PERMISSIONS_INVALID_ENTITY', 'PERMISSIONS_INVALID_PRINCIPAL', 'PERMISSIONS_INVALID_TARGET', 'PREVIOUS_SELF', 'SUPPLY_INVALID', 'TOKEN_RECEIVE_DIFFERS'];
 const client_FullBlockErrorCodes = client_BlockErrorCodes.map(code => `${client_BlockErrorType}_${code}`);
 class src_client_KeetaNetBlockError extends src_client_KeetaNetErrorBase {
   constructor(code, message) {
@@ -118007,7 +118623,11 @@ class src_client_BlockOperation {
     if (amount === undefined || amount === null) {
       throw new Error('internal error: "amount" is invalid');
     }
-    return BigInt(amount);
+    const bigintAmount = BigInt(amount);
+    if (bigintAmount < 0n) {
+      throw new src_client_KeetaNetBlockError('BLOCK_AMOUNT_BELOW_ZERO', 'value cannot be negative');
+    }
+    return bigintAmount;
   }
 }
 client_BlockOperation = src_client_BlockOperation;
@@ -118226,7 +118846,7 @@ class src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends src_client_Blo
     }
     client_operations_classPrivateFieldSet(client_token3, this, client_operations_assertClassBrand(client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_brand, this, client_computeToken3).call(this, input.token));
     client_operations_classPrivateFieldSet(client_amount3, this, this.computeAmount(input.amount));
-    client_operations_classPrivateFieldSet(client_method, this, input.method);
+    client_operations_classPrivateFieldSet(client_method, this, client_toAdjustMethod(input.method));
   }
   set token(token) {
     client_operations_classPrivateFieldSet(client_token3, this, client_operations_assertClassBrand(client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE_brand, this, client_computeToken3).call(this, token));
@@ -118235,7 +118855,7 @@ class src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends src_client_Blo
     return client_operations_classPrivateFieldGet(client_token3, this);
   }
   set method(newMethod) {
-    client_operations_classPrivateFieldSet(client_method, this, newMethod);
+    client_operations_classPrivateFieldSet(client_method, this, client_toAdjustMethod(newMethod));
   }
   get method() {
     return Number(client_operations_classPrivateFieldGet(client_method, this));
@@ -118573,7 +119193,7 @@ class src_client_BlockOperationMODIFY_PERMISSIONS extends src_client_BlockOperat
     }
     client_operations_classPrivateFieldSet(client_principal, this, this.computeTo(input.principal));
     client_operations_classPrivateFieldSet(client_target, this, client_lib_account.toAccount(input.target));
-    client_operations_classPrivateFieldSet(client_method2, this, input.method);
+    client_operations_classPrivateFieldSet(client_method2, this, client_toAdjustMethod(input.method));
     client_operations_classPrivateFieldSet(client_permissions, this, client_operations_assertClassBrand(client_BlockOperationMODIFY_PERMISSIONS_brand, this, client_computePermissions).call(this, input.permissions));
   }
   set principal(principal) {
@@ -118595,7 +119215,7 @@ class src_client_BlockOperationMODIFY_PERMISSIONS extends src_client_BlockOperat
     return client_operations_classPrivateFieldGet(client_target, this);
   }
   set method(method) {
-    client_operations_classPrivateFieldSet(client_method2, this, method);
+    client_operations_classPrivateFieldSet(client_method2, this, client_toAdjustMethod(method));
   }
   get method() {
     return Number(client_operations_classPrivateFieldGet(client_method2, this));
@@ -119877,6 +120497,7 @@ class src_client_Block {
     if (this.account.isMultisig()) {
       throw new src_client_KeetaNetBlockError('BLOCK_NO_MULTISIG_OP', 'Cannot create a block for a multisig account');
     }
+    client_block_assertClassBrand(client_Block_brand, this, client_validateBytes).call(this);
     client_block_assertClassBrand(client_Block_brand, this, client_validateSignerField).call(this);
     client_block_assertClassBrand(client_Block_brand, this, client_validateOperationsPurpose).call(this);
     client_block_assertClassBrand(client_Block_brand, this, client_validateSignatures).call(this);
@@ -119886,8 +120507,11 @@ class src_client_Block {
   }
   toBytes() {
     let includeSignatures = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    if (client_block_classPrivateFieldGet(client_valueBytes, this) !== undefined && includeSignatures) {
-      return client_block_classPrivateFieldGet(client_valueBytes, this);
+    let useCached = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (useCached) {
+      if (client_block_classPrivateFieldGet(client_valueBytes, this) !== undefined && includeSignatures) {
+        return client_block_classPrivateFieldGet(client_valueBytes, this);
+      }
     }
     const sharedBlockValues = {
       previous: this.previous,
@@ -120077,6 +120701,19 @@ function client_getSortedRequiredSigners(input) {
   }
   return out;
 }
+function client_validateBytes() {
+  const existingBytes = client_block_classPrivateFieldGet(client_valueBytes, this);
+  if (existingBytes === undefined) {
+    return;
+  }
+  const recalculatedBytesBuffer = client_block_Buffer.from(this.toBytes(true, false));
+  const existingBytesBuffer = client_block_Buffer.from(existingBytes);
+  if (!recalculatedBytesBuffer.equals(existingBytesBuffer)) {
+    const existingBytesHash = client_block_Buffer.from(client_hash_Hash(existingBytesBuffer)).toString('hex').toUpperCase();
+    const recalculatedBytesHash = client_block_Buffer.from(client_hash_Hash(recalculatedBytesBuffer)).toString('hex').toUpperCase();
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_SIGNATURE', `Block signed bytes (${existingBytesHash}) do not match calculated bytes (${recalculatedBytesHash})`);
+  }
+}
 function client_validateOperationsPurpose() {
   /**
    * Do not allow blocks to contain invalid constructions
@@ -120134,7 +120771,7 @@ function client_validateSignatures() {
     const signature = new src_client_BufferStorage(this.signatures[i], 64);
     const valid = signers[i].verify(this.hash.get(), signature.get());
     if (valid !== true) {
-      throw new Error(`Unable to validate signature of ${this.hash.toString()} against signature ${this.signatures[i]} for account ${signers[i].publicKeyString.get()}`);
+      throw new src_client_KeetaNetBlockError('BLOCK_INVALID_SIGNATURE', `Unable to validate signature of ${this.hash.toString()} against signature ${this.signatures[i].toString('hex')} for account ${signers[i].publicKeyString.get()}`);
     }
   }
 }
@@ -124592,6 +125229,10 @@ function client_updateAccountInfoInState(state, account, info) {
  * Compute the effect of a SEND operation
  */
 function client_computeEffectOfOperationSEND(state, block, operation) {
+  if (operation.amount < 0n) {
+    throw new Error('Internal error: SEND operation with negative amount');
+  }
+
   // Decrement sender balance
   const senderChange = {
     state,
@@ -124621,6 +125262,10 @@ function client_computeEffectOfOperationSEND(state, block, operation) {
  * Compute the effect of a RECEIVE operation
  */
 function client_computeEffectOfOperationRECEIVE(state, block, operation) {
+  if (operation.amount < 0n) {
+    throw new Error('Internal error: RECEIVE operation with negative amount');
+  }
+
   // Increment recipient balance
   const recipientChange = {
     state,
@@ -124656,6 +125301,9 @@ function client_computeEffectOfOperationRECEIVE(state, block, operation) {
   }
 }
 function client_computeEffectOfOperationTOKEN_ADMIN_MODIFY_BALANCE(state, block, operation) {
+  if (operation.amount < 0n) {
+    throw new Error('Internal error: TOKEN_ADMIN_MODIFY_BALANCE operation with negative amount');
+  }
   if (operation.method === src_client_Block.AdjustMethod.SET) {
     const setChange = {
       state,
@@ -124732,6 +125380,9 @@ function client_computeEffectOfOperationCREATE_IDENTIFIER(state, block, operatio
     client_updateAccountInfoInState(state, operation.identifier, {
       multisigQuorum: operation.createArguments.quorum
     });
+    if (operation.createArguments.quorum < 1n || operation.createArguments.quorum > BigInt(operation.createArguments.signers.length)) {
+      throw new Error('Internal error: operation.createArguments.quorum is invalid');
+    }
     for (const multisigSigner of operation.createArguments.signers) {
       state.possibleNewAccounts.add(multisigSigner);
       client_addPermission(state, {
@@ -124773,6 +125424,9 @@ function client_computeEffectOfOperationMODIFY_PERMISSIONS(state, block, operati
 }
 function client_computeEffectOfOperationTOKEN_ADMIN_SUPPLY(state, block, operation) {
   var _state$accounts$token;
+  if (operation.amount < 0n) {
+    throw new Error('Internal error: TOKEN_ADMIN_SUPPLY operation with negative amount');
+  }
   const tokenPubKey = block.account.publicKeyString.get();
   let value = 0n;
   switch (operation.method) {
@@ -125606,6 +126260,10 @@ class client_Log {
    * Register a new logging target (sink) to send logs to
    */
   registerTarget(target) {
+    if (client_log_classPrivateFieldGet(client_destroyed, this)) {
+      throw new Error('Cannot register target on destroyed Log instance');
+    }
+
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const id = Symbol('LogTargetID');
     client_log_classPrivateFieldGet(client_targets, this).set(id, target);
@@ -125627,6 +126285,9 @@ class client_Log {
    * Unregister a logging target (sink) to stop sending logs to
    */
   unregisterTarget(id) {
+    if (client_log_classPrivateFieldGet(client_destroyed, this)) {
+      return;
+    }
     client_log_classPrivateFieldGet(client_targets, this).delete(id);
   }
 
@@ -125644,6 +126305,9 @@ class client_Log {
    */
   startAutoSync() {
     let rate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;
+    if (client_log_classPrivateFieldGet(client_destroyed, this)) {
+      throw new Error('Cannot start auto sync on destroyed Log instance');
+    }
     this.stopAutoSync();
     client_log_classPrivateFieldSet(client_autoSyncInterval, this, setInterval(async () => {
       try {
@@ -125721,6 +126385,15 @@ class client_Log {
     this.destroy();
   }
 
+  /**
+   * Dispose of the logger instance, syncing all logs, and clearing targets
+   */
+  async [Symbol.asyncDispose]() {
+    client_log_classPrivateFieldSet(client_destroyed, this, true);
+    await this.sync();
+    this.destroy();
+  }
+
   /**
    * Terminate the logger instance, clearing all logs and targets
    */
@@ -125735,6 +126408,9 @@ class client_Log {
   }
 }
 function client_log_log(level, options, from) {
+  if (client_log_classPrivateFieldGet(client_destroyed, this)) {
+    return;
+  }
   for (var _len6 = arguments.length, args = new Array(_len6 > 3 ? _len6 - 3 : 0), _key6 = 3; _key6 < _len6; _key6++) {
     args[_key6 - 3] = arguments[_key6];
   }
@@ -125794,7 +126470,6 @@ function client_timing_classPrivateFieldSet(s, a, r) { return s.set(client_timin
 function client_timing_classPrivateFieldGet(s, a) { return s.get(client_timing_assertClassBrand(s, a)); }
 function client_timing_assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 
-
 /**
  * Support the old way of doing timing where the callers could call
  * startTime/endTime with the same string to terminate a timing section
@@ -125820,8 +126495,13 @@ class client_RequestTiming {
   constructor() {
     client_timing_classPrivateFieldInitSpec(this, client_timing, new Map());
     client_timing_classPrivateFieldInitSpec(this, client_counter, 0);
-    client_timing_defineProperty(this, "log", client_RequestTiming.defaultLogger);
+    if (client_RequestTiming.defaultLogger === '@legacy') {
+      this.log = src_client_log.Legacy();
+    } else {
+      this.log = client_RequestTiming.defaultLogger;
+    }
   }
+
   /**
    * Start timing a section of code
    * @param section Name of the section to time -- should be unique within the code base so that it can be identified later
@@ -125835,12 +126515,17 @@ class client_RequestTiming {
       start: Date.now()
     };
     client_timing_classPrivateFieldGet(client_timing, this).set(id, data);
+    let endCalled = false;
     return {
-      id,
+      id: id,
       end: () => {
+        endCalled = true;
         this.endTime(id);
       },
       [Symbol.dispose]: () => {
+        if (endCalled) {
+          return;
+        }
         this.endTime(id);
       }
     };
@@ -125859,11 +126544,11 @@ class client_RequestTiming {
     if (typeof section === 'symbol') {
       const timingInfo = client_timing_classPrivateFieldGet(client_timing, this).get(section);
       if (timingInfo === undefined) {
-        this.log.error(`Timing section ${String(section)} does not exist but "end" was called on it!`);
+        this.log.error('timing::endTime', `Timing section ${String(section)} does not exist but "end" was called on it!`);
         return;
       }
       if (timingInfo.end !== undefined) {
-        this.log.error(`Timing section ${timingInfo.id} already ended but "end" was called on it again!`);
+        this.log.error('timing::endTime', `Timing section ${timingInfo.id} already ended but "end" was called on it again!`);
         return;
       }
       timingInfo.end = Date.now();
@@ -125963,7 +126648,7 @@ class client_RequestTiming {
     return client_timing_classPrivateFieldSet(client_counter, this, (_this$counter = client_timing_classPrivateFieldGet(client_counter, this), _this$counter2 = _this$counter++, _this$counter)), _this$counter2;
   }
 }
-client_timing_defineProperty(client_RequestTiming, "defaultLogger", src_client_log.Legacy());
+client_timing_defineProperty(client_RequestTiming, "defaultLogger", '@legacy');
 /* harmony default export */ const src_client_timing = (client_RequestTiming);
 ;// ./src/lib/kv/index.ts
 function client_kv_defineProperty(e, r, t) { return (r = client_kv_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -128150,7 +128835,7 @@ client_lib_ledger_defineProperty(src_client_Ledger, "isInstance", client_checkab
 // EXTERNAL MODULE: ws (ignored)
 var client_ws_ignored_ = __webpack_require__(4708);
 ;// ./src/version.ts
-const client_version = '0.14.11+gfb27e304d06f586fd5f3532fae4f1504a46d359b';
+const client_version = '0.14.13+g566b8de2c01660608e6eb5257113db271d7fc075';
 /* harmony default export */ const client_src_version = ((/* unused pure expression or super */ null && (client_version)));
 ;// ./src/lib/p2p.ts
 /* provided dependency */ var client_p2p_Buffer = __webpack_require__(8287)["Buffer"];
@@ -130385,7 +131070,7 @@ function client_client_toPrimitive(t, r) { if ("object" != typeof t || !t) retur
 
 
 const client_ClientErrorType = 'CLIENT';
-const client_ClientErrorCodes = ['BUILDER_AMOUNT_IS_ZERO', 'BUILDER_CANNOT_READ_BEFORE_RENDER', 'BUILDER_REQUIRES_PRIVATE_KEY', 'BUILDER_USER_CLIENT_REQUIRED', 'PUBLISH_AID_NOT_AVAILABLE', 'SIGNER_REQUIRES_PRIVATE_KEY', 'SYNC_PUBLISH_FAILED', 'SWAP_INVALID_ACCOUNT_OPTION', 'SWAP_OPTIONS_INVALID', 'SWAP_MISSING_SEND', 'SWAP_MISSING_RECEIVE', 'SWAP_SEND_RECEIVE_ACCOUNT_MISMATCH', 'SWAP_SEND_ACCOUNT_MISMATCH', 'SWAP_REQUEST_TOKEN_MISMATCH', 'SWAP_REQUEST_AMOUNT_MISMATCH'];
+const client_ClientErrorCodes = ['BUILDER_AMOUNT_IS_ZERO', 'BUILDER_CANNOT_READ_BEFORE_RENDER', 'BUILDER_REQUIRES_PRIVATE_KEY', 'BUILDER_USER_CLIENT_REQUIRED', 'PUBLISH_AID_NOT_AVAILABLE', 'SIGNER_REQUIRES_PRIVATE_KEY', 'SYNC_PUBLISH_FAILED', 'SWAP_INVALID_ACCOUNT_OPTION', 'SWAP_OPTIONS_INVALID', 'SWAP_MISSING_SEND', 'SWAP_MISSING_RECEIVE', 'SWAP_SEND_RECEIVE_ACCOUNT_MISMATCH', 'SWAP_SEND_ACCOUNT_MISMATCH', 'SWAP_SEND_TOKEN_MISMATCH', 'SWAP_SEND_AMOUNT_TOO_LOW', 'SWAP_SEND_AMOUNT_RECEIVE_EXACT_MISMATCH', 'SWAP_REQUEST_TOKEN_MISMATCH', 'SWAP_REQUEST_AMOUNT_MISMATCH'];
 const client_FullClientErrorCodes = client_ClientErrorCodes.map(code => `${client_ClientErrorType}_${code}`);
 class src_client_KeetaNetClientError extends src_client_KeetaNetErrorBase {
   constructor(code, message) {
@@ -133686,6 +134371,9 @@ client_src_client_defineProperty(src_client_Client, "Config", client_config_name
 client_src_client_defineProperty(src_client_Client, "DefaultLogger", console);
 client_src_client_defineProperty(src_client_Client, "updateRepsInterval", 5 * 60 * 1000);
 client_src_client_defineProperty(src_client_Client, "isInstance", client_checkableGenerator(client_Client));
+/**
+ * @deprecated Use the new structure with `receive` and `send` fields instead
+ */
 const client_defaultListenerOptions = {
   change: {
     fallbackFrequency: 60 * 1000
@@ -133823,6 +134511,7 @@ class src_client_UserClient {
    * @returns Swap {@link Block}
    */
   static async createSwapRequest(request, client, options) {
+    var _request$to$exact;
     let userClient;
     if (src_client_UserClient.isInstance(client)) {
       userClient = client;
@@ -133844,7 +134533,7 @@ class src_client_UserClient {
       account: request.from.account
     });
     builder.send(to.account, from.amount, from.token);
-    builder.receive(to.account, to.amount, to.token, true);
+    builder.receive(to.account, to.amount, to.token, (_request$to$exact = request.to.exact) !== null && _request$to$exact !== void 0 ? _request$to$exact : false);
     const blocks = await builder.computeBlocks();
     if (blocks.blocks.length !== 1) {
       throw new Error('Compute Swap Request Generated more than 1 block');
@@ -133861,7 +134550,6 @@ class src_client_UserClient {
    */
 
   static async acceptSwapRequest(request, builderOrUserClient, options) {
-    var _request$expected, _request$expected2, _request$expected3, _request$expected4;
     let builder;
     let account;
     if (src_client_UserClientBuilder.isInstance(builderOrUserClient)) {
@@ -133870,15 +134558,16 @@ class src_client_UserClient {
     } else {
       let userClient;
       if (src_client_UserClient.isInstance(builderOrUserClient)) {
+        var _options$account;
         userClient = builderOrUserClient;
-        account = builderOrUserClient.account;
+        account = (_options$account = options === null || options === void 0 ? void 0 : options.account) !== null && _options$account !== void 0 ? _options$account : builderOrUserClient.account;
       } else try {
-        var _options$account;
+        var _options$account2;
         var _usingCtx = client_client_usingCtx2();
         // Use await using so this temporary client gets cleaned up
         const temporaryClient = _usingCtx.a(this.fromNetwork(builderOrUserClient.network, builderOrUserClient.signer, options));
         userClient = temporaryClient;
-        account = (_options$account = options === null || options === void 0 ? void 0 : options.account) !== null && _options$account !== void 0 ? _options$account : builderOrUserClient.signer;
+        account = (_options$account2 = options === null || options === void 0 ? void 0 : options.account) !== null && _options$account2 !== void 0 ? _options$account2 : builderOrUserClient.signer;
         if (account === null) {
           throw new src_client_KeetaNetClientError('CLIENT_SWAP_INVALID_ACCOUNT_OPTION', 'Signer is required for building swap block');
         }
@@ -133916,13 +134605,41 @@ class src_client_UserClient {
     if (!sendOperation.to.comparePublicKey(account)) {
       throw new src_client_KeetaNetClientError('CLIENT_SWAP_SEND_ACCOUNT_MISMATCH', 'Swap Request send account does not match');
     }
-    if (((_request$expected = request.expected) === null || _request$expected === void 0 ? void 0 : _request$expected.token) !== undefined && !sendOperation.token.comparePublicKey((_request$expected2 = request.expected) === null || _request$expected2 === void 0 ? void 0 : _request$expected2.token)) {
-      throw new src_client_KeetaNetClientError('CLIENT_SWAP_REQUEST_TOKEN_MISMATCH', 'Swap Request send token does not match expected');
-    }
-    if (((_request$expected3 = request.expected) === null || _request$expected3 === void 0 ? void 0 : _request$expected3.amount) !== undefined && sendOperation.amount !== ((_request$expected4 = request.expected) === null || _request$expected4 === void 0 ? void 0 : _request$expected4.amount)) {
-      throw new src_client_KeetaNetClientError('CLIENT_SWAP_REQUEST_AMOUNT_MISMATCH', 'Swap Request send amount does not match expected');
+    let sendAmount = receiveOperation.amount;
+    if (request.expected) {
+      let expectedReceive;
+      let expectedSend;
+      if ('receive' in request.expected || 'send' in request.expected) {
+        var _request$expected, _request$expected2;
+        expectedReceive = (_request$expected = request.expected) === null || _request$expected === void 0 ? void 0 : _request$expected.receive;
+        expectedSend = (_request$expected2 = request.expected) === null || _request$expected2 === void 0 ? void 0 : _request$expected2.send;
+      } else if ('token' in request.expected || 'amount' in request.expected) {
+        expectedReceive = request.expected;
+      }
+      if (expectedReceive) {
+        if (expectedReceive.token !== undefined && !sendOperation.token.comparePublicKey(expectedReceive.token)) {
+          throw new src_client_KeetaNetClientError('CLIENT_SWAP_REQUEST_TOKEN_MISMATCH', 'Swap Request send token does not match expected');
+        }
+        if (expectedReceive.amount !== undefined && sendOperation.amount !== expectedReceive.amount) {
+          throw new src_client_KeetaNetClientError('CLIENT_SWAP_REQUEST_AMOUNT_MISMATCH', 'Swap Request send amount does not match expected');
+        }
+      }
+      if (expectedSend) {
+        if (expectedSend.token !== undefined && !expectedSend.token.comparePublicKey(receiveOperation.token)) {
+          throw new src_client_KeetaNetClientError('CLIENT_SWAP_SEND_TOKEN_MISMATCH', 'Swap acceptance send token does not match swap request receive token');
+        }
+        if (expectedSend.amount !== undefined) {
+          if (expectedSend.amount < receiveOperation.amount) {
+            throw new src_client_KeetaNetClientError('CLIENT_SWAP_SEND_AMOUNT_TOO_LOW', 'Send amount must be at least the receive amount specified in the swap request');
+          }
+          if (receiveOperation.exact && receiveOperation.amount !== expectedSend.amount) {
+            throw new src_client_KeetaNetClientError('CLIENT_SWAP_SEND_AMOUNT_RECEIVE_EXACT_MISMATCH', 'Send value is not allowed to differ from expected receive amount for exact receives');
+          }
+          sendAmount = expectedSend.amount;
+        }
+      }
     }
-    builder.send(request.block.account, receiveOperation.amount, receiveOperation.token);
+    builder.send(request.block.account, sendAmount, receiveOperation.token);
     const blocks = await builder.computeBlocks();
     return [...blocks.blocks, request.block];
   }
@@ -134304,9 +135021,9 @@ class src_client_UserClient {
    */
 
   async getCertificates(certificateHash) {
-    var _options$account2;
+    var _options$account3;
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const account = (_options$account2 = options.account) !== null && _options$account2 !== void 0 ? _options$account2 : this.account;
+    const account = (_options$account3 = options.account) !== null && _options$account3 !== void 0 ? _options$account3 : this.account;
     if (certificateHash !== undefined) {
       return await client_client_classPrivateFieldGet(client_client, this).getCertificateByHash(account, certificateHash);
     }
@@ -134810,9 +135527,9 @@ class src_client_UserClient {
 /** @hidden */
 client_UserClient = src_client_UserClient;
 function client_getAccount() {
-  var _ref3, _options$account3;
+  var _ref3, _options$account4;
   let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  const retval = (_ref3 = (_options$account3 = options.account) !== null && _options$account3 !== void 0 ? _options$account3 : client_client_classPrivateFieldGet(client_client_config, this).account) !== null && _ref3 !== void 0 ? _ref3 : this.signer;
+  const retval = (_ref3 = (_options$account4 = options.account) !== null && _options$account4 !== void 0 ? _options$account4 : client_client_classPrivateFieldGet(client_client_config, this).account) !== null && _ref3 !== void 0 ? _ref3 : this.signer;
   if (retval === null) {
     throw new Error('No signer available in a read-only UserClient');
   }