Run zig fmt

joncinque · joncinque · commit fd9bd9fb9e2e · 2024-11-15T14:28:46.000+01:00
diff --git a/token/zig/src/instruction.zig b/token/zig/src/instruction.zig
@@ -54,13 +54,13 @@ pub fn IxOption(T: type) type {
             }
         }
         pub fn fromValue(value: T) Self {
-            return Self {
+            return Self{
                 .is_some = 1,
                 .value = value,
             };
         }
         pub fn fromNull() Self {
-            return Self {
+            return Self{
                 .is_some = 0,
                 .value = std.mem.zeroes(T),
             };
@@ -73,7 +73,7 @@ pub fn IxOption(T: type) type {
             }
         }
         pub fn toCOption(self: Self) COption(T) {
-            return COption(T) {
+            return COption(T){
                 .is_some = self.is_some,
                 .value = self.value,
             };
@@ -92,7 +92,7 @@ pub const InitializeMintData = packed struct {
 
 pub const AmountData = packed struct {
     /// The amount of tokens to process.
-    amount: u64
+    amount: u64,
 };
 
 pub const Instruction = union(InstructionDiscriminant) {
diff --git a/token/zig/src/main.zig b/token/zig/src/main.zig
@@ -316,27 +316,27 @@ fn processInstruction(program_id: *align(1) PublicKey, accounts: []sol.Account,
             //}
 
             //if !source_account.is_owned_by_system_program_or_incinerator() {
-                //match source_account.delegate {
-                    //COption::Some(ref delegate) if Self::cmp_pubkeys(authority_info.key, delegate) => {
-                        //Self::validate_owner(
-                            //program_id,
-                            //delegate,
-                            //authority_info,
-                            //account_info_iter.as_slice(),
-                        //)?;
-
-                        //if source_account.delegated_amount < amount {
-                            //return Err(TokenError::InsufficientFunds.into());
-                        //}
-                        //source_account.delegated_amount = source_account
-                            //.delegated_amount
-                            //.checked_sub(amount)
-                            //.ok_or(TokenError::Overflow)?;
-                        //if source_account.delegated_amount == 0 {
-                            //source_account.delegate = COption::None;
-                        //}
-                    //}
-                //}
+            //match source_account.delegate {
+            //COption::Some(ref delegate) if Self::cmp_pubkeys(authority_info.key, delegate) => {
+            //Self::validate_owner(
+            //program_id,
+            //delegate,
+            //authority_info,
+            //account_info_iter.as_slice(),
+            //)?;
+
+            //if source_account.delegated_amount < amount {
+            //return Err(TokenError::InsufficientFunds.into());
+            //}
+            //source_account.delegated_amount = source_account
+            //.delegated_amount
+            //.checked_sub(amount)
+            //.ok_or(TokenError::Overflow)?;
+            //if source_account.delegated_amount == 0 {
+            //source_account.delegate = COption::None;
+            //}
+            //}
+            //}
             //}
             try validateOwner(
                 program_id,
@@ -383,17 +383,19 @@ fn processInstruction(program_id: *align(1) PublicKey, accounts: []sol.Account,
             }
 
             const authority = if (source.close_authority.is_some != 0)
-                source.close_authority.value else source.owner;
+                source.close_authority.value
+            else
+                source.owner;
 
             //if !source_account.is_owned_by_system_program_or_incinerator() {
-                //Self::validate_owner(
-                    //program_id,
-                    //&authority,
-                    //authority_info,
-                    //account_info_iter.as_slice(),
-                //)?;
+            //Self::validate_owner(
+            //program_id,
+            //&authority,
+            //authority_info,
+            //account_info_iter.as_slice(),
+            //)?;
             //} else if !solana_program::incinerator::check_id(destination_account_info.key) {
-                //return Err(ProgramError::InvalidAccountData);
+            //return Err(ProgramError::InvalidAccountData);
             //}
 
             try validateOwner(
@@ -465,8 +467,7 @@ fn validateOwner(
     if (!expected_owner.equals(owner_account.id())) {
         return TokenError.OwnerMismatch;
     }
-    if (program_id.equals(owner_account.ownerId()) and owner_account.dataLen() == state.Multisig.len)
-    {
+    if (program_id.equals(owner_account.ownerId()) and owner_account.dataLen() == state.Multisig.len) {
         //let multisig = Multisig::unpack(&owner_account_info.data.borrow())?;
         //let mut num_signers = 0;
         //let mut matched = [false; MAX_SIGNERS];
@@ -482,7 +483,7 @@ fn validateOwner(
         //    }
         //}
         //if num_signers < multisig.m {
-            return TokenError.MissingRequiredSignature;
+        return TokenError.MissingRequiredSignature;
         //}
     } else if (!owner_account.isSigner()) {
         return TokenError.MissingRequiredSignature;
diff --git a/token/zig/src/state.zig b/token/zig/src/state.zig
@@ -47,13 +47,13 @@ pub fn COption(T: type) type {
             }
         }
         pub fn fromValue(value: T) Self {
-            return Self {
+            return Self{
                 .is_some = 1,
                 .value = value,
             };
         }
         pub fn asNull() Self {
-            return Self {
+            return Self{
                 .is_some = 0,
                 .value = std.mem.zeroes(T),
             };
@@ -73,36 +73,35 @@ pub const Multisig = packed struct {
 };
 
 test "Mint: bitCast" {
-    const mint = Mint {
+    const mint = Mint{
         .authority = COption(PublicKey).fromOptional(std.mem.bytesToValue(PublicKey, &[_]u8{1} ** 32)),
         .supply = 42,
         .decimals = 7,
         .is_initialized = 1,
         .freeze_authority = COption(PublicKey).fromOptional(std.mem.bytesToValue(PublicKey, &[_]u8{2} ** 32)),
     };
     const mint_buffer = [_]u8{
-        1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 0, 0, 0, 1, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
         1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2,  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     };
     try std.testing.expectEqualSlices(u8, &mint_buffer, std.mem.asBytes(&mint)[0..82]);
     const cast_mint: Mint = @bitCast(mint_buffer);
     try std.testing.expectEqual(cast_mint, mint);
 }
 
 test "Mint: cast with padding" {
-    const mint = Mint {
+    const mint = Mint{
         .authority = COption(PublicKey).new(std.mem.bytesToValue(PublicKey, &[_]u8{1} ** 32)),
         .supply = 42,
         .decimals = 7,
         .is_initialized = 1,
         .freeze_authority = COption(PublicKey).new(std.mem.bytesToValue(PublicKey, &[_]u8{2} ** 32)),
     };
     const mint_buffer = [_]u8{
-        0,
-        1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-        1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        0, 1, 0, 0, 0, 1, 1,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 42, 0, 0, 0, 0, 0, 0, 0, 7, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2,  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
     };
     try std.testing.expectEqualSlices(u8, mint_buffer[1..], std.mem.asBytes(&mint)[0..82]);
     const cast_mint: *const Mint = @alignCast(@ptrCast(mint_buffer[1..]));
