Merge pull request #53 from LucasSte/solang-release

Update examples according to use the annotation syntax

Author: ZYJLiu

basics/checking-accounts/solang/solidity/checking-accounts.sol

@@ -8,21 +8,15 @@ contract checking_accounts {
     @payer(payer) // "payer" is the account that pays to create the dataAccount
     constructor() {}
 
-    function checkAccounts(address accountToChange, address accountToCreate) public view {
+    @account(accountToChange)
+    @mutableSigner(accountToCreate)
+    function checkAccounts(address accountToChange, address accountToCreate) external view {
         print("Number of Accounts Provided: {:}".format(tx.accounts.length));
 
-        // Find the accounts we are looking for and perform checks on them
-        for (uint64 i = 0; i < tx.accounts.length; i++) {
-            if (tx.accounts[i].key == accountToChange) {
-                print("Found Account To Change");
-                programOwnerCheck(tx.accounts[i]);
-            }
-            if (tx.accounts[i].key == accountToCreate) {
-                print("Found Account To Create");
-                notInitializedCheck(tx.accounts[i]);
-                signerCheck(tx.accounts[i]);
-            }
-        }
+        // Perform checks on the account
+        programOwnerCheck(tx.accounts.accountToChange);
+        notInitializedCheck(tx.accounts.accountToCreate);
+        signerCheck(tx.accounts.accountToCreate);
 
         // (Create account...) (unimplemented)
         // (Change account...) (unimplemented)

basics/checking-accounts/solang/tests/checking-accounts.ts

@@ -55,19 +55,10 @@ describe("checking-accounts", () => {
     // Invoke the checkAccounts instruction on our program, passing in the account we want to "check"
     const tx = await program.methods
       .checkAccounts(accountToChange.publicKey, accountToCreate.publicKey)
-      .accounts({ dataAccount: dataAccount.publicKey })
-      .remainingAccounts([
-        {
-          pubkey: accountToChange.publicKey,
-          isWritable: true,
-          isSigner: false,
-        },
-        {
-          pubkey: accountToCreate.publicKey,
-          isWritable: true,
-          isSigner: true,
-        },
-      ])
+      .accounts({ 
+        accountToCreate: accountToCreate.publicKey,
+        accountToChange: accountToChange.publicKey,
+    })
       .signers([accountToCreate])
       .rpc({ skipPreflight: true });
     console.log("Your transaction signature", tx);

basics/cross-program-invocation/solang/solidity/hand.sol

@@ -2,7 +2,7 @@
 import "solana";
 
 // Interface to the lever program.
-leverInterface constant leverProgram = leverInterface(address'4wFN9As94uDgcBK9umEi6DNjRLi8gq7jaHwSw3829xq8');
+@program_id("4wFN9As94uDgcBK9umEi6DNjRLi8gq7jaHwSw3829xq8")
 interface leverInterface {
     function switchPower(string name) external;
 }
@@ -16,17 +16,18 @@ contract hand {
     constructor() {}
 
     // "Pull the lever" by calling the switchPower instruction on the lever program via a Cross Program Invocation.
-    function pullLever(address dataAccount, string name) public {
+    @mutableAccount(leverData)
+    function pullLever(string name) external {
         // The account required by the switchPower instruction.
         // This is the data account created by the lever program (not this program), which stores the state of the switch.
         AccountMeta[1] metas = [
-            AccountMeta({pubkey: dataAccount, is_writable: true, is_signer: false})
+            AccountMeta({pubkey: tx.accounts.leverData.key, is_writable: true, is_signer: false})
         ];
 
         // The data required by the switchPower instruction.
         string instructionData = name;
 
         // Invoke the switchPower instruction on the lever program.
-        leverProgram.switchPower{accounts: metas}(instructionData);
+        leverInterface.switchPower{accounts: metas}(instructionData);
     }
 }

basics/cross-program-invocation/solang/tests/test.ts

@@ -47,20 +47,11 @@ describe("cross-program-invocation", () => {
 
     // Call the pullLever instruction on the hand program, which invokes the lever program via CPI
     const tx2 = await handProgram.methods
-      .pullLever(dataAccountLever.publicKey, "Chris")
-      .accounts({ dataAccount: dataAccountHand.publicKey })
-      .remainingAccounts([
-        {
-          pubkey: dataAccountLever.publicKey, // The lever program's data account, which stores the state
-          isWritable: true,
-          isSigner: false,
-        },
-        {
-          pubkey: leverProgram.programId, // The lever program's program ID
-          isWritable: false,
-          isSigner: false,
-        },
-      ])
+      .pullLever("Chris")
+      .accounts({ 
+        leverData: dataAccountLever.publicKey, // The lever program's data account, which stores the state
+        leverInterface_programId: leverProgram.programId // The lever program's program ID
+        })
       .rpc({ skipPreflight: true });
     console.log("Your transaction signature", tx2);
 
@@ -76,20 +67,11 @@ describe("cross-program-invocation", () => {
   it("Pull it again!", async () => {
     // Call the pullLever instruction on the hand program, which invokes the lever program via CPI
     const tx = await handProgram.methods
-      .pullLever(dataAccountLever.publicKey, "Ashley")
-      .accounts({ dataAccount: dataAccountHand.publicKey })
-      .remainingAccounts([
-        {
-          pubkey: dataAccountLever.publicKey, // The lever program's data account, which stores the state
-          isWritable: true,
-          isSigner: false,
-        },
-        {
-          pubkey: leverProgram.programId, // The lever program's program ID
-          isWritable: false,
-          isSigner: false,
-        },
-      ])
+      .pullLever("Ashley")
+      .accounts({ 
+        leverData: dataAccountLever.publicKey, // The lever program's data account, which stores the state
+        leverInterface_programId: leverProgram.programId, // The lever program's program ID
+       })
       .rpc({ skipPreflight: true });
 
     console.log("Your transaction signature", tx);

basics/hello-solana/solang/solidity/hello-solana.sol

@@ -5,8 +5,8 @@ contract hello_solana {
     // Here we create a new account that stores no data and only prints messages to the program logs when the constructor is called.
     @payer(payer) // The "payer" pays for the account creation
     constructor() {
-        // We get the program ID by calling 'type(hello_solana).program_id', where "hello_solana" is the name of the contract.
-        address programId = type(hello_solana).program_id;
+        // We get the program ID by calling 'this';
+        address programId = address(this);
 
         // Print messages to the program logs
         print("Hello, Solana!");

basics/pda-rent-payer/solang/solidity/pda-rent-payer.sol

@@ -8,7 +8,7 @@ contract pda_rent_payer {
     @seed("rent_vault") // hardcoded seed
     constructor(@bump bytes1 bump, uint64 fundLamports) {
         // Independently derive the PDA address from the seeds, bump, and programId
-        (address pda, bytes1 _bump) = try_find_program_address(["rent_vault"], type(pda_rent_payer).program_id);
+        (address pda, bytes1 _bump) = try_find_program_address(["rent_vault"], address(this));
 
         // Verify that the bump passed to the constructor matches the bump derived from the seeds and programId
         // This ensures that only the canonical pda address can be used to create the account (first bump that generates a valid pda address)
@@ -17,14 +17,16 @@ contract pda_rent_payer {
         // Fund the pda account with additional lamports
         SystemInstruction.transfer(
             tx.accounts.payer.key, // from
-            address(this), // to (the address of the account being created)
+            tx.accounts.dataAccount.key, // to (the address of the account being created)
             fundLamports // amount of lamports to transfer
         );
     }
 
-    function createNewAccount(uint64 lamports) public {
-        AccountInfo from = tx.accounts[0]; // first account must be an account owned by the program
-        AccountInfo to = tx.accounts[1]; // second account must be the intended recipient
+    @mutableAccount(ownedByProgram)
+    @mutableAccount(intendedRecipient)
+    function createNewAccount(uint64 lamports) external {
+        AccountInfo from = tx.accounts.ownedByProgram; // an account owned by the program
+        AccountInfo to = tx.accounts.intendedRecipient; // second account must be the intended recipient
 
         print("From: {:}".format(from.key));
         print("To: {:}".format(to.key));

basics/pda-rent-payer/solang/tests/pda-rent-payer.ts

@@ -44,14 +44,10 @@ describe("pda-rent-payer", () => {
     // Invoke the createNewAccount instruction on our program
     const tx = await program.methods
       .createNewAccount(new anchor.BN(lamports))
-      .accounts({ dataAccount: dataAccountPDA })
-      .remainingAccounts([
-        {
-          pubkey: newAccount.publicKey, // account to create by directly transferring lamports
-          isWritable: true,
-          isSigner: false,
-        },
-      ])
+      .accounts({ 
+        ownedByProgram: dataAccountPDA,
+        intendedRecipient: newAccount.publicKey, // account to create by directly transferring lamports
+    })
       .rpc();
     console.log("Your transaction signature", tx);
 

basics/rent/solang/solidity/rent.sol

@@ -8,13 +8,15 @@ contract rent {
     @payer(payer) // The "payer" pays for the data account creation
     constructor() {}
 
-    function createSystemAccount(address payer, address newAccount, uint64 space) public {
+    @mutableSigner(payer)
+    @mutableSigner(newAccount)
+    function createSystemAccount(uint64 space) external {
         // The minimum lamports required for the amount of space allocated to the account
         uint64 lamports = minimum_balance(space);
 
         SystemInstruction.create_account(
-            payer,        // lamports sent from this account (payer)
-            newAccount, // lamports sent to this account (account to be created)
+            tx.accounts.payer.key,        // lamports sent from this account (payer)
+            tx.accounts.newAccount.key, // lamports sent to this account (account to be created)
             lamports,      // lamport amount (minimum lamports required)
             space,          // space required for the account
             SystemInstruction.systemAddress // program owner (system program)

basics/rent/solang/tests/rent.ts

@@ -33,24 +33,13 @@ describe("rent", () => {
     // Create a new account via a Cross Program Invocation to the system program
     const tx = await program.methods
       .createSystemAccount(
-        wallet.publicKey, // payer
-        newAccount.publicKey, // new account
         new anchor.BN(space) // space
       )
-      .accounts({ dataAccount: dataAccount.publicKey })
+      .accounts({ 
+        payer: wallet.publicKey,
+        newAccount: newAccount.publicKey,
+       })
       .signers([newAccount]) // new account keypair required as signer
-      .remainingAccounts([
-        {
-          pubkey: wallet.publicKey,
-          isWritable: true,
-          isSigner: true,
-        },
-        {
-          pubkey: newAccount.publicKey, // new account
-          isWritable: true,
-          isSigner: true,
-        },
-      ])
       .rpc();
     console.log("Your transaction signature", tx);
   });

basics/transfer-sol/solang/solidity/transfer-sol.sol

@@ -10,16 +10,20 @@ contract transfer_sol {
     }
 
     // Transfer SOL from one account to another using CPI (Cross Program Invocation) to the System program
-    function transferSolWithCpi(address from, address to, uint64 lamports) public {
+    @mutableSigner(sender)
+    @mutableAccount(recipient)
+    function transferSolWithCpi(uint64 lamports) external {
         // CPI to transfer SOL using "system_instruction" library
-        SystemInstruction.transfer(from, to, lamports);
+        SystemInstruction.transfer(tx.accounts.sender.key, tx.accounts.recipient.key, lamports);
     }
 
     // Transfer SOL from program owned account to another address by directly modifying the account data lamports
     // This approach only works for accounts owned by the program itself (ex. the dataAccount created in the constructor)
-    function transferSolWithProgram(uint64 lamports) public {
-        AccountInfo from = tx.accounts[0]; // first account must be an account owned by the program
-        AccountInfo to = tx.accounts[1]; // second account must be the intended recipient
+    @mutableAccount(sender)
+    @mutableAccount(recipient)
+    function transferSolWithProgram(uint64 lamports) external {
+        AccountInfo from = tx.accounts.sender; // first account must be an account owned by the program
+        AccountInfo to = tx.accounts.recipient; // second account must be the intended recipient
 
         print("From: {:}".format(from.key));
         print("To: {:}".format(to.key));