Bump Zig to 0.15 (#10)

#### Problem

The repo is still on Zig 0.14.

#### Summary of changes

Update everything, along with tests.

Author: joncinque

.github/workflows/main.yml

@@ -1,4 +1,4 @@
-name: Build and test library
+name: Main
 
 on:
   push:
@@ -18,13 +18,13 @@ jobs:
       - uses: actions/checkout@v2
       - uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.14.0
+          version: 0.15.2
       - run: zig build test --summary all
   lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: goto-bus-stop/setup-zig@v2
         with:
-          version: 0.14.0
+          version: 0.15.2
       - run: zig fmt --check .

build.zig

@@ -1,71 +1,32 @@
 const std = @import("std");
 
-// Although this function looks imperative, note that its job is to
-// declaratively construct a build graph that will be executed by an external
-// runner.
 pub fn build(b: *std.Build) void {
-    // Standard target options allows the person running `zig build` to choose
-    // what target to build for. Here we do not override the defaults, which
-    // means any target is allowed, and the default is native. Other options
-    // for restricting supported target set are available.
     const target = b.standardTargetOptions(.{});
-
-    // Standard optimization options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
-    // set a preferred release mode, allowing the user to decide how to optimize.
     const optimize = b.standardOptimizeOption(.{});
 
     const dep_opts = .{ .target = target, .optimize = optimize };
-    // Export self as a module
     const sol_lib_mod = b.addModule("solana_program_library", .{
         .root_source_file = b.path("src/root.zig"),
         .target = target,
         .optimize = optimize,
     });
 
-    const lib = b.addStaticLibrary(.{
-        .name = "solana_program_library",
-        // In this case the main source file is merely a path, however, in more
-        // complicated build scripts, this could be a generated file.
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
     // Adding it as a module
     const solana_dep = b.dependency("solana_program_sdk", dep_opts);
     const solana_mod = solana_dep.module("solana_program_sdk");
-    lib.root_module.addImport("solana_program_sdk", solana_mod);
     sol_lib_mod.addImport("solana_program_sdk", solana_mod);
 
     const bincode_dep = b.dependency("bincode", .{
         .target = target,
         .optimize = optimize,
     });
     const bincode_mod = bincode_dep.module("bincode");
-    lib.root_module.addImport("bincode", bincode_mod);
     sol_lib_mod.addImport("bincode", bincode_mod);
 
-    // This declares intent for the library to be installed into the standard
-    // location when the user invokes the "install" step (the default step when
-    // running `zig build`).
-    b.installArtifact(lib);
-
-    // Creates a step for unit testing. This only builds the test executable
-    // but does not run it.
     const lib_unit_tests = b.addTest(.{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = sol_lib_mod,
     });
-    lib_unit_tests.root_module.addImport("solana_program_sdk", solana_mod);
-    lib_unit_tests.root_module.addImport("bincode", bincode_mod);
-
     const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
-
-    // Similar to creating the run step earlier, this exposes a `test` step to
-    // the `zig build --help` menu, providing a way for the user to request
-    // running the unit tests.
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&run_lib_unit_tests.step);
 }

build.zig.zon

@@ -1,22 +1,18 @@
 .{
     .fingerprint = 0xa4b85d3595fe4ad7,
     .name = .solana_program_library,
-
-    .version = "0.15.1",
-
-    .minimum_zig_version = "0.14.0",
-
+    .version = "0.16.0",
+    .minimum_zig_version = "0.15.0",
     .dependencies = .{
         .bincode = .{
-            .url = "https://github.com/joncinque/bincode-zig/archive/refs/tags/v0.14.0.tar.gz",
-            .hash = "bincode-0.14.0-LYspxE5uAABpwu-W95yJ9swZ3YhGkgbwaGwVjzNZGNXH",
+            .url = "https://github.com/joncinque/bincode-zig/archive/refs/tags/v0.15.1.tar.gz",
+            .hash = "bincode-0.15.1-LYspxORwAAC0ty6JQz_DAmUk2gHiOMmJnYveMUEW939Z",
         },
         .solana_program_sdk = .{
-            .url = "https://github.com/joncinque/solana-program-sdk-zig/archive/refs/tags/v0.16.3.tar.gz",
-            .hash = "solana_program_sdk-0.16.3-wGj9UHnjAADiUN0cEUQGAbMCpDDiNUhKI5xkCuiFNGhr",
+            .url = "https://github.com/joncinque/solana-program-sdk-zig/archive/refs/tags/v0.17.0.tar.gz",
+            .hash = "solana_program_sdk-0.17.0-wGj9UHjiAAC5lyL1BQ4MI7wcQYrqSjHrxdvZXDaA8Glb",
         },
     },
-
     .paths = .{
         "build.zig",
         "build.zig.zon",

src/associated_token_account.zig

@@ -2,8 +2,12 @@ const std = @import("std");
 const bincode = @import("bincode");
 const sol = @import("solana_program_sdk");
 
+const Account = sol.account.Account;
+const ProgramDerivedAddress = sol.public_key.ProgramDerivedAddress;
+const PublicKey = sol.public_key.PublicKey;
+
 const AssociatedTokenAccountProgram = @This();
-pub const id = sol.PublicKey.comptimeFromBase58("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+pub const id = PublicKey.comptimeFromBase58("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 
 pub const Instruction = union(enum(u8)) {
     /// Creates an associated token account for the given wallet address and token mint
@@ -48,31 +52,31 @@ pub const Instruction = union(enum(u8)) {
     recover_nested: void,
 };
 
-pub fn getAssociatedTokenAccountAddressWithProgramId(wallet_address: sol.PublicKey, mint_address: sol.PublicKey) !sol.PublicKey {
+pub fn getAssociatedTokenAccountAddressWithProgramId(wallet_address: PublicKey, mint_address: PublicKey) !PublicKey {
     const pda = try getAssociatedTokenAccountAddressAndBumpSeed(wallet_address, mint_address);
     return pda.address;
 }
 
-pub fn getAssociatedTokenAccountAddressAndBumpSeed(wallet_address: sol.PublicKey, mint_address: sol.PublicKey, token_program_id: sol.PublicKey) !sol.ProgramDerivedAddress {
-    return sol.PublicKey.findProgramAddress(.{ wallet_address, token_program_id, mint_address }, id);
+pub fn getAssociatedTokenAccountAddressAndBumpSeed(wallet_address: PublicKey, mint_address: PublicKey, token_program_id: PublicKey) !ProgramDerivedAddress {
+    return PublicKey.findProgramAddress(.{ wallet_address, token_program_id, mint_address }, id);
 }
 
 pub fn createAccount(params: struct {
-    funder: sol.Account.Info,
-    account: sol.Account.Info,
-    owner: sol.Account.Info,
-    mint: sol.Account.Info,
-    system_program: sol.Account.Info,
-    token_program: sol.Account.Info,
-    rent: sol.Account.Info,
+    funder: Account.Info,
+    account: Account.Info,
+    owner: Account.Info,
+    mint: Account.Info,
+    system_program: Account.Info,
+    token_program: Account.Info,
+    rent: Account.Info,
     seeds: []const []const []const u8 = &.{},
 }) !void {
     var data: [1]u8 = undefined;
     _ = try bincode.writeToSlice(&data, AssociatedTokenAccountProgram.Instruction.create, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
-        .accounts = &[_]sol.Account.Param{
+        .accounts = &[_]Account.Param{
             .{ .id = params.funder.id, .is_writable = true, .is_signer = true },
             .{ .id = params.account.id, .is_writable = true, .is_signer = false },
             .{ .id = params.owner.id, .is_writable = false, .is_signer = false },
@@ -96,21 +100,21 @@ pub fn createAccount(params: struct {
 }
 
 pub fn createIdempotentAccount(params: struct {
-    funder: sol.Account.Info,
-    account: sol.Account.Info,
-    owner: sol.Account.Info,
-    mint: sol.Account.Info,
-    system_program: sol.Account.Info,
-    token_program: sol.Account.Info,
-    associated_token_program: sol.Account.Info,
+    funder: Account.Info,
+    account: Account.Info,
+    owner: Account.Info,
+    mint: Account.Info,
+    system_program: Account.Info,
+    token_program: Account.Info,
+    associated_token_program: Account.Info,
     seeds: []const []const []const u8 = &.{},
 }) !void {
     var data: [1]u8 = undefined;
     _ = try bincode.writeToSlice(&data, AssociatedTokenAccountProgram.Instruction.create_idempotent, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
-        .accounts = &[_]sol.Account.Param{
+        .accounts = &[_]Account.Param{
             .{ .id = params.funder.id, .is_writable = true, .is_signer = true },
             .{ .id = params.account.id, .is_writable = true, .is_signer = false },
             .{ .id = params.owner.id, .is_writable = false, .is_signer = false },
@@ -133,22 +137,22 @@ pub fn createIdempotentAccount(params: struct {
 }
 
 pub fn recoverNestedAccount(params: struct {
-    account: sol.Account.Info,
-    nested_mint: sol.Account.Info,
-    destination_associated_account: sol.Account.Info,
-    owner_associated_account: sol.Account.Info,
-    owner_mint: sol.Account.Info,
-    owner: sol.Account.Info,
-    token_program: sol.Account.Info,
-    associated_token_program: sol.Account.Info,
+    account: Account.Info,
+    nested_mint: Account.Info,
+    destination_associated_account: Account.Info,
+    owner_associated_account: Account.Info,
+    owner_mint: Account.Info,
+    owner: Account.Info,
+    token_program: Account.Info,
+    associated_token_program: Account.Info,
     seeds: []const []const []const u8 = &.{},
 }) !void {
     var data: [1]u8 = undefined;
     _ = try bincode.writeToSlice(&data, AssociatedTokenAccountProgram.Instruction.recover_nested, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
-        .accounts = &[_]sol.Account.Param{
+        .accounts = &[_]Account.Param{
             .{ .id = params.account.id, .is_writable = true, .is_signer = false },
             .{ .id = params.nested_mint.id, .is_writable = false, .is_signer = false },
             .{ .id = params.destination_associated_account.id, .is_writable = true, .is_signer = false },

src/compute_budget.zig

@@ -2,57 +2,59 @@ const std = @import("std");
 const sol = @import("solana_program_sdk");
 const bincode = @import("bincode");
 
-const Account = sol.Account;
+const Account = sol.account.Account;
+const PublicKey = sol.public_key.PublicKey;
+const SolInstruction = sol.instruction.Instruction;
 
 const ComputeBudget = @This();
 
-pub const id = sol.PublicKey.comptimeFromBase58("ComputeBudget111111111111111111111111111111");
+pub const id = PublicKey.comptimeFromBase58("ComputeBudget111111111111111111111111111111");
 
-pub fn requestHeapFrame(allocator: std.mem.Allocator, bytes: u32) !sol.Instruction {
+pub fn requestHeapFrame(allocator: std.mem.Allocator, bytes: u32) !SolInstruction {
     const data = try bincode.writeAlloc(allocator, ComputeBudget.Instruction{
         .request_heap_frame = .{ .bytes = bytes },
     }, .default);
 
-    return sol.Instruction.from(.{
+    return SolInstruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{},
-        .data = data,
+        .data = data.items,
     });
 }
 
-pub fn setComputeUnitLimit(allocator: std.mem.Allocator, compute_units: u32) !sol.Instruction {
+pub fn setComputeUnitLimit(allocator: std.mem.Allocator, compute_units: u32) !SolInstruction {
     const data = try bincode.writeAlloc(allocator, ComputeBudget.Instruction{
         .set_compute_unit_limit = .{ .compute_units = compute_units },
     }, .default);
 
-    return sol.Instruction.from(.{
+    return SolInstruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{},
-        .data = data,
+        .data = data.items,
     });
 }
 
-pub fn setComputeUnitPrice(allocator: std.mem.Allocator, micro_lamports: u64) !sol.Instruction {
+pub fn setComputeUnitPrice(allocator: std.mem.Allocator, micro_lamports: u64) !SolInstruction {
     const data = try bincode.writeAlloc(allocator, ComputeBudget.Instruction{
         .set_compute_unit_price = .{ .micro_lamports = micro_lamports },
     }, .default);
 
-    return sol.Instruction.from(.{
+    return SolInstruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{},
-        .data = data,
+        .data = data.items,
     });
 }
 
-pub fn setLoadedAccountsDataSizeLimit(allocator: std.mem.Allocator, bytes: u32) !sol.Instruction {
+pub fn setLoadedAccountsDataSizeLimit(allocator: std.mem.Allocator, bytes: u32) !SolInstruction {
     const data = try bincode.writeAlloc(allocator, ComputeBudget.Instruction{
         .set_loaded_accounts_data_size_limit = .{ .bytes = bytes },
     }, .default);
 
-    return sol.Instruction.from(.{
+    return SolInstruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{},
-        .data = data,
+        .data = data.items,
     });
 }
 

src/system.zig

@@ -2,8 +2,8 @@ const std = @import("std");
 const bincode = @import("bincode");
 const sol = @import("solana_program_sdk");
 
-const Account = sol.Account;
-const PublicKey = sol.PublicKey;
+const Account = sol.account.Account;
+const PublicKey = sol.public_key.PublicKey;
 
 const SystemProgram = @This();
 pub const id = PublicKey.comptimeFromBase58("11111111111111111111111111111111");
@@ -25,7 +25,7 @@ pub fn createAccount(params: struct {
         },
     }, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{
             .{ .id = params.from.id, .is_writable = true, .is_signer = true },
@@ -48,7 +48,7 @@ pub fn transfer(params: struct {
         .transfer = .{ .lamports = params.lamports },
     }, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{
             .{ .id = params.from.id, .is_writable = true, .is_signer = true },
@@ -70,7 +70,7 @@ pub fn allocate(params: struct {
         .allocate = .{ .space = params.space },
     }, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{
             .{ .id = params.account.id, .is_writable = true, .is_signer = true },
@@ -91,7 +91,7 @@ pub fn assign(params: struct {
         .assign = .{ .owner_id = params.owner_id },
     }, .default);
 
-    const instruction = sol.Instruction.from(.{
+    const instruction = sol.instruction.Instruction.from(.{
         .program_id = &id,
         .accounts = &[_]Account.Param{
             .{ .id = params.account.id, .is_writable = true, .is_signer = true },
@@ -246,8 +246,8 @@ pub const Instruction = union(enum(u32)) {
 };
 
 test "SystemProgram.Instruction: serialize and deserialize" {
-    var buffer = std.ArrayList(u8).init(std.testing.allocator);
-    defer buffer.deinit();
+    var writer = std.Io.Writer.Allocating.init(std.testing.allocator);
+    defer writer.deinit();
 
     inline for (.{ bincode.Params.default, bincode.Params.legacy, bincode.Params.standard }) |params| {
         inline for (.{
@@ -259,10 +259,12 @@ test "SystemProgram.Instruction: serialize and deserialize" {
                 },
             },
         }) |payload| {
-            try bincode.write(buffer.writer(), payload, params);
-            var stream = std.io.fixedBufferStream(buffer.items);
-            try std.testing.expectEqual(payload, try bincode.read(std.testing.allocator, @TypeOf(payload), stream.reader(), params));
-            buffer.clearRetainingCapacity();
+            try bincode.write(&writer.writer, payload, params);
+            var buffer = writer.toArrayList();
+            defer buffer.deinit(std.testing.allocator);
+            var reader = std.Io.Reader.fixed(buffer.items);
+            try std.testing.expectEqual(payload, try bincode.read(std.testing.allocator, @TypeOf(payload), &reader, params));
+            writer.clearRetainingCapacity();
         }
     }
 }