Struct Field23E 

pub struct Field23E {
    pub instruction_code: String,
    pub additional_info: Option<String>,
}

Field 23E: Instruction Code

Purpose

Specifies detailed payment instructions and processing directives that complement the bank operation code in Field 23B. This field provides granular control over payment processing, delivery methods, and special handling requirements essential for precise transaction execution and compliance with specific service levels.

Format Specification

• Swift Format: 4!c[/30x]
• Structure: Mandatory instruction code + optional additional information
• Instruction Code: Exactly 4 alphabetic characters (uppercase)
• Additional Info: Up to 30 characters for supplementary details

Business Context Applications

• Payment Instructions: Specific delivery and processing directives
• Service Level Compliance: Instructions aligned with Field 23B service levels
• Special Handling: Non-standard processing requirements
• Delivery Methods: Communication and notification preferences

Instruction Code Categories

Standard Delivery Instructions

• SDVA: Same day value (immediate processing)
• TELB: Telephone beneficiary before crediting
• PHOB: Phone beneficiary organization before payment
• INTC: Intermediary contact required

Communication Instructions

• TELE: Telephone advice required
• TELEAUTH: Telephone authorization needed
• HOLD: Hold payment for specific conditions
• RETN: Return if undeliverable

Network Validation Requirements

• Service Level Constraints: Availability depends on Field 23B value
• SPRI Service: Only SDVA, TELB, PHOB, INTC allowed with Priority Service
• SSTD/SPAY Services: Field 23E must not be present
• Character Set: Standard SWIFT character set for additional information
• Length Validation: Additional info maximum 30 characters

Field 23B Integration Rules

Priority Service Level (SPRI)

• Allowed Codes: SDVA, TELB, PHOB, INTC only
• Processing Impact: Immediate execution requirements
• Validation Rule: C3 constraint enforcement
• STP Compliance: Enhanced straight-through processing

Standard/SWIFTPay Service (SSTD/SPAY)

• Field Restriction: Field 23E must not be present
• Automated Processing: No manual intervention instructions
• STP Requirements: Full automation compliance
• Error Prevention: C3 rule violation avoidance

Regional Considerations

• Local Practices: Regional instruction code interpretation
• Central Bank Rules: Regulatory instruction requirements
• Correspondent Capabilities: Institution-specific instruction support
• Settlement Systems: Local system instruction integration

Processing Impact

Same Day Value (SDVA)

• Timing: Immediate value date processing
• Priority: High priority execution
• Settlement: Same day settlement requirements
• Cost: Potential premium charges

Communication Requirements (TELB/PHOB)

• Manual Intervention: Human contact required
• Processing Delay: Additional processing time
• Verification: Beneficiary confirmation needed
• Documentation: Contact record maintenance

Error Prevention Guidelines

• Service Level Validation: Verify compatibility with Field 23B
• Instruction Appropriateness: Confirm instruction necessity
• Additional Info Format: Ensure character set compliance
• Processing Capability: Verify recipient institution capability

Related Fields Integration

• Field 23B: Bank Operation Code (service level dependency)
• Field 13C: Time Indication (timing coordination)
• Field 72: Sender to Receiver Information (instruction context)
• Field 57A: Account with Institution (delivery coordination)

Compliance Framework

• Service Level Agreements: Instruction compliance with SLAs
• Regulatory Requirements: Instruction regulatory compliance
• Operational Procedures: Standard operating procedure alignment
• Audit Documentation: Instruction rationale documentation

Usage Examples

:23E:SDVA             // Same day value instruction
:23E:TELB/URGENT      // Telephone beneficiary with urgency note
:23E:PHOB/CONFIRM     // Phone organization with confirmation required
:23E:INTC/AUTH REQ    // Intermediary contact with authorization request

Best Practices

• Selective Usage: Only include when necessary for processing
• Service Level Alignment: Ensure compatibility with Field 23B
• Clear Instructions: Provide clear additional information
• Cost Consideration: Understand fee implications of special instructions

See Also

• Swift FIN User Handbook: Instruction Code Specifications
• MT103 Usage Rules: Field 23E Implementation Guidelines
• Service Level Guide: Instruction Code Compatibility Matrix

Fields

instruction_code: String

Instruction code

additional_info: Option<String>

Additional information (optional)

Trait Implementations

impl Clone for Field23E

fn clone(&self) -> Field23E

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Field23E

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Field23E

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Field23E

fn eq(&self, other: &Field23E) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Field23E

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SwiftField for Field23E

fn parse(value: &str) -> Result<Self>

Parse field value from string representation

fn to_swift_string(&self) -> String

Convert field back to SWIFT string format

fn format_spec() -> &'static str

Get field format specification

fn parse_with_variant( value: &str, _variant: Option<&str>, _field_tag: Option<&str>, ) -> Result<Self>

where Self: Sized,

Parse field value with variant hint for enum fields Default implementation falls back to regular parse

fn valid_variants() -> Option<Vec<&'static str>>

Get valid variant letters for enum fields Returns None for non-enum fields, Some(vec) for enum fields

impl StructuralPartialEq for Field23E