Use the latest @solana/solidity npm version

Signed-off-by: Sean Young <sean@mess.org>

integration/solana/balances.spec.ts

@@ -13,11 +13,11 @@ describe('Deploy solang contract and test', () => {
             accounts: [payerAccount.publicKey],
         });
 
-        let bal = Number(res.result);
+        let bal = Number(res.result[0]);
 
         let rpc_bal = await connection.getBalance(payerAccount.publicKey);
 
-        expect(bal).toBe(rpc_bal);
+        expect(bal + 5000).toBe(rpc_bal);
 
         // @solana/solidity needs a fix for this
         // res = await token.functions.pay_me({

integration/solana/builtins.spec.ts

@@ -11,24 +11,24 @@ describe('Deploy solang contract and test', () => {
         console.log("calling ripemd160");
         let res = await token.functions.hash_ripemd160('0x' + Buffer.from('Call me Ishmael.', 'utf8').toString('hex'));
 
-        expect(res.result).toBe("0x0c8b641c461e3c7abbdabd7f12a8905ee480dadf");
+        expect(res.result[0]).toBe("0x0c8b641c461e3c7abbdabd7f12a8905ee480dadf");
 
         console.log("calling sha256");
         res = await token.functions.hash_sha256('0x' + Buffer.from('Call me Ishmael.', 'utf8').toString('hex'), { simulate: true });
 
-        expect(res.result).toBe("0x458f3ceeeec730139693560ecf66c9c22d9c7bc7dcb0599e8e10b667dfeac043");
+        expect(res.result[0]).toBe("0x458f3ceeeec730139693560ecf66c9c22d9c7bc7dcb0599e8e10b667dfeac043");
 
         console.log("calling keccak256");
         res = await token.functions.hash_kecccak256('0x' + Buffer.from('Call me Ishmael.', 'utf8').toString('hex'));
 
-        expect(res.result).toBe("0x823ad8e1757b879aac338f9a18542928c668e479b37e4a56f024016215c5928c");
+        expect(res.result[0]).toBe("0x823ad8e1757b879aac338f9a18542928c668e479b37e4a56f024016215c5928c");
 
         console.log("calling timestamp");
         res = await token.functions.mr_now([]);
 
         let now = Math.floor(+new Date() / 1000);
 
-        let ts = Number(res.result);
+        let ts = Number(res.result[0]);
 
         expect(ts).toBeLessThanOrEqual(now);
         expect(ts).toBeGreaterThan(now - 120);
@@ -36,7 +36,7 @@ describe('Deploy solang contract and test', () => {
         console.log("calling slot");
         res = await token.functions.mr_slot();
 
-        let sol_slot = Number(res.result);
+        let sol_slot = Number(res.result[0]);
 
         let rpc_slot = await connection.getSlot();
         console.log("slot from rpc " + rpc_slot);

integration/solana/calls.spec.ts

@@ -1,5 +1,5 @@
 import expect from 'expect';
-import { loadProgram } from './utils';
+import { loadContract, load2ndContract } from './utils';
 import { Keypair } from '@solana/web3.js';
 import fs from 'fs';
 
@@ -7,70 +7,46 @@ describe('Deploy solang contract and test', () => {
     it('external_call', async function () {
         this.timeout(100000);
 
-        const [program, connnection, payerAccount] = await loadProgram();
 
-        const callerStorageKeyPair = Keypair.generate();
+        const [caller, connection, payerAccount, program] = await loadContract('caller', 'caller.abi');
 
-        const caller = (await program.deployContract({
-            name: 'caller',
-            abi: fs.readFileSync('caller.abi', 'utf8'),
-            space: 8192,
-            storageKeyPair: callerStorageKeyPair,
-            constructorArgs: []
-        })).contract;
+        const callee = await load2ndContract(connection, program, payerAccount, 'callee', 'callee.abi');
 
-        const calleeStorageKeyPair = Keypair.generate();
 
-        const callee = (await program.deployContract({
-            name: 'callee',
-            abi: fs.readFileSync('callee.abi', 'utf8'),
-            space: 8192,
-            storageKeyPair: calleeStorageKeyPair,
-            constructorArgs: []
-        })).contract;
-
-
-        const callee2StorageKeyPair = Keypair.generate();
-        const callee2 = (await program.deployContract({
-            name: 'callee2',
-            abi: fs.readFileSync('callee2.abi', 'utf8'),
-            space: 8192,
-            storageKeyPair: callee2StorageKeyPair,
-            constructorArgs: []
-        })).contract;
+        const callee2 = await load2ndContract(connection, program, payerAccount, 'callee2', 'callee2.abi');
 
         await callee.functions.set_x(102);
 
         let res = await callee.functions.get_x({ simulate: true });
 
-        expect(Number(res.result)).toBe(102);
+        expect(Number(res.result[0])).toBe(102);
 
-        let address_caller = '0x' + callerStorageKeyPair.publicKey.toBuffer().toString('hex');
-        let address_callee = '0x' + calleeStorageKeyPair.publicKey.toBuffer().toString('hex');
-        let address_callee2 = '0x' + callee2StorageKeyPair.publicKey.toBuffer().toString('hex');
+        let address_caller = '0x' + caller.storage.toBuffer().toString('hex');
+        let address_callee = '0x' + callee.storage.toBuffer().toString('hex');
+        let address_callee2 = '0x' + callee2.storage.toBuffer().toString('hex');
         console.log("addres: " + address_callee);
 
         res = await caller.functions.who_am_i({ simulate: true });
 
-        expect(res.result).toBe(address_caller);
+        expect(res.result[0]).toBe(address_caller);
 
         await caller.functions.do_call(address_callee, "13123", {
-            writableAccounts: [calleeStorageKeyPair.publicKey],
-            accounts: [program.programAccount.publicKey]
+            writableAccounts: [callee.storage],
+            accounts: [program.publicKey]
         });
 
         res = await callee.functions.get_x({ simulate: true });
 
-        expect(Number(res.result)).toBe(13123);
+        expect(Number(res.result[0])).toBe(13123);
 
         res = await caller.functions.do_call2(address_callee, 20000, {
             simulate: true,
-            accounts: [calleeStorageKeyPair.publicKey, program.programAccount.publicKey]
+            accounts: [callee.storage, program.publicKey]
         });
 
-        expect(Number(res.result)).toBe(33123);
+        expect(Number(res.result[0])).toBe(33123);
 
-        let all_keys = [program.programAccount.publicKey, calleeStorageKeyPair.publicKey, callee2StorageKeyPair.publicKey];
+        let all_keys = [program.publicKey, callee.storage, callee2.storage];
 
         res = await caller.functions.do_call3(address_callee, address_callee2, ["3", "5", "7", "9"], "yo", { accounts: all_keys });
 

integration/solana/errors.spec.ts

@@ -1,4 +1,4 @@
-import { TransactionError } from '@solana/solidity';
+import { SimulationError } from '@solana/solidity';
 import expect from 'expect';
 import { loadContract } from './utils';
 
@@ -10,13 +10,13 @@ describe('Deploy solang contract and test', () => {
 
         let res = await token.functions.do_revert(false);
 
-        expect(Number(res.result)).toEqual(3124445);
+        expect(Number(res.result[0])).toEqual(3124445);
 
         try {
             res = await token.functions.do_revert(true, { simulate: true });
         } catch (e) {
-            expect(e).toBeInstanceOf(TransactionError);
-            if (e instanceof TransactionError) {
+            expect(e).toBeInstanceOf(SimulationError);
+            if (e instanceof SimulationError) {
                 expect(e.message).toBe('Do the revert thing');
                 expect(e.computeUnitsUsed).toBe(1050);
                 expect(e.logs.length).toBeGreaterThan(1);
@@ -27,8 +27,8 @@ describe('Deploy solang contract and test', () => {
         try {
             res = await token.functions.do_revert(true);
         } catch (e) {
-            expect(e).toBeInstanceOf(TransactionError);
-            if (e instanceof TransactionError) {
+            expect(e).toBeInstanceOf(SimulationError);
+            if (e instanceof SimulationError) {
                 expect(e.message).toBe('Do the revert thing');
                 expect(e.computeUnitsUsed).toBe(1050);
                 expect(e.logs.length).toBeGreaterThan(1);

integration/solana/oznfc.spec.ts

@@ -9,19 +9,19 @@ describe('Deploy solang contract and test', () => {
 
         let res = await token.functions.getName();
 
-        expect(res.result).toBe("myName");
+        expect(res.result[0]).toBe("myName");
 
         await token.functions.setName('ozan');
 
         res = await token.functions.getName();
 
-        expect(res.result).toBe('ozan');
+        expect(res.result[0]).toBe('ozan');
 
         await token.functions.setSurname('martin');
 
         res = await token.functions.getSurname();
 
-        expect(res.result).toBe('martin');
+        expect(res.result[0]).toBe('martin');
 
         res = await token.functions.getNames();
 

integration/solana/package.json

@@ -18,10 +18,10 @@
     "typescript": "^4.1.2"
   },
   "dependencies": {
-    "@solana/solidity": "0.0.16",
+    "@solana/solidity": "0.0.17",
     "ethers": "^5.2.0",
     "web3-eth-abi": "^1.3.0",
     "web3-utils": "^1.3.0",
     "tweetnacl": "^1.0.3"
   }
-}
+}

integration/solana/simple.spec.ts

@@ -10,13 +10,13 @@ describe('Deploy solang contract and test', () => {
 
         let res = await token.functions.get({ simulate: true });
 
-        expect(res.result).toBe(true);
+        expect(res.result).toStrictEqual([true]);
 
         await token.functions.flip();
 
         res = await token.functions.get({ simulate: true });
 
-        expect(res.result).toBe(false);
+        expect(res.result).toStrictEqual([false]);
     });
 
     it('primitives', async function () {
@@ -28,112 +28,112 @@ describe('Deploy solang contract and test', () => {
         // in ethereum, an enum is described as an uint8 so can't use the enum
         // names programmatically. 0 = add, 1 = sub, 2 = mul, 3 = div, 4 = mod, 5 = pow, 6 = shl, 7 = shr
         let res = await token.functions.is_mul(2, { simulate: true });
-        expect(res.result).toBe(true);
+        expect(res.result[0]).toBe(true);
 
         res = await token.functions.return_div({ simulate: true });
-        expect(res.result).toBe(3);
+        expect(res.result[0]).toBe(3);
 
         // TEST uint and int types, and arithmetic/bitwise ops
         res = await token.functions.op_i64(0, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(5100);
+        expect(Number(res.result[0])).toBe(5100);
         res = await token.functions.op_i64(1, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(-3100);
+        expect(Number(res.result[0])).toBe(-3100);
         res = await token.functions.op_i64(2, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(4100000);
+        expect(Number(res.result[0])).toBe(4100000);
         res = await token.functions.op_i64(3, 1000, 10, { simulate: true });
-        expect(Number(res.result)).toBe(100);
+        expect(Number(res.result[0])).toBe(100);
         res = await token.functions.op_i64(4, 1000, 99, { simulate: true });
-        expect(Number(res.result)).toBe(10);
+        expect(Number(res.result[0])).toBe(10);
         res = await token.functions.op_i64(6, - 1000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(-256000);
+        expect(Number(res.result[0])).toBe(-256000);
         res = await token.functions.op_i64(7, - 1000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(-4);
+        expect(Number(res.result[0])).toBe(-4);
 
 
         res = await token.functions.op_u64(0, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(5100);
+        expect(Number(res.result[0])).toBe(5100);
         res = await token.functions.op_u64(1, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(18446744073709548516); // (2^64)-18446744073709548516 = 3100
+        expect(Number(res.result[0])).toBe(18446744073709548516); // (2^64)-18446744073709548516 = 3100
         res = await token.functions.op_u64(2, 123456789, 123456789, { simulate: true });
-        expect(Number(res.result)).toBe(15241578750190521);
+        expect(Number(res.result[0])).toBe(15241578750190521);
         res = await token.functions.op_u64(3, 123456789, 100, { simulate: true });
-        expect(Number(res.result)).toBe(1234567);
+        expect(Number(res.result[0])).toBe(1234567);
         res = await token.functions.op_u64(4, 123456789, 100, { simulate: true });
-        expect(Number(res.result)).toBe(89);
+        expect(Number(res.result[0])).toBe(89);
         res = await token.functions.op_u64(5, 3, 7, { simulate: true });
-        expect(Number(res.result)).toBe(2187);
+        expect(Number(res.result[0])).toBe(2187);
         res = await token.functions.op_i64(6, 1000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(256000);
+        expect(Number(res.result[0])).toBe(256000);
         res = await token.functions.op_i64(7, 1000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(3);
+        expect(Number(res.result[0])).toBe(3);
 
         // now for 256 bit operations
         res = await token.functions.op_i256(0, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(5100);
+        expect(Number(res.result[0])).toBe(5100);
         res = await token.functions.op_i256(1, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(-3100);
+        expect(Number(res.result[0])).toBe(-3100);
         res = await token.functions.op_i256(2, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(4100000);
+        expect(Number(res.result[0])).toBe(4100000);
         res = await token.functions.op_i256(3, 1000, 10, { simulate: true });
-        expect(Number(res.result)).toBe(100);
+        expect(Number(res.result[0])).toBe(100);
         res = await token.functions.op_i256(4, 1000, 99, { simulate: true });
-        expect(Number(res.result)).toBe(10);
+        expect(Number(res.result[0])).toBe(10);
         res = await token.functions.op_i256(6, - 10000000000000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(-2560000000000000);
+        expect(Number(res.result[0])).toBe(-2560000000000000);
         res = await token.functions.op_i256(7, - 10000000000000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(-39062500000);
+        expect(Number(res.result[0])).toBe(-39062500000);
 
         res = await token.functions.op_u256(0, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(5100);
+        expect(Number(res.result[0])).toBe(5100);
         res = await token.functions.op_u256(1, 1000, 4100, { simulate: true });
-        expect(Number(res.result)).toBe(115792089237316195423570985008687907853269984665640564039457584007913129636836); // (2^64)-18446744073709548516 = 3100
+        expect(Number(res.result[0])).toBe(115792089237316195423570985008687907853269984665640564039457584007913129636836); // (2^64)-18446744073709548516 = 3100
         res = await token.functions.op_u256(2, 123456789, 123456789, { simulate: true });
-        expect(Number(res.result)).toBe(15241578750190521);
+        expect(Number(res.result[0])).toBe(15241578750190521);
         res = await token.functions.op_u256(3, 123456789, 100, { simulate: true });
-        expect(Number(res.result)).toBe(1234567);
+        expect(Number(res.result[0])).toBe(1234567);
         res = await token.functions.op_u256(4, 123456789, 100, { simulate: true });
-        expect(Number(res.result)).toBe(89);
+        expect(Number(res.result[0])).toBe(89);
         res = await token.functions.op_u256(5, 123456789, 9, { simulate: true });
-        expect(Number(res.result)).toBe(6662462759719942007440037531362779472290810125440036903063319585255179509);
+        expect(Number(res.result[0])).toBe(6662462759719942007440037531362779472290810125440036903063319585255179509);
         res = await token.functions.op_i256(6, 10000000000000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(2560000000000000);
+        expect(Number(res.result[0])).toBe(2560000000000000);
         res = await token.functions.op_i256(7, 10000000000000, 8, { simulate: true });
-        expect(Number(res.result)).toBe(39062500000);
+        expect(Number(res.result[0])).toBe(39062500000);
 
 
         // TEST bytesN
         res = await token.functions.return_u8_6({ simulate: true });
-        expect(res.result).toBe("0x414243444546");
+        expect(res.result[0]).toBe("0x414243444546");
 
         // TEST bytes5
         res = await token.functions.op_u8_5_shift(6, "0xdeadcafe59", 8, { simulate: true });
-        expect(res.result).toBe("0xadcafe5900");
+        expect(res.result[0]).toBe("0xadcafe5900");
         res = await token.functions.op_u8_5_shift(7, "0xdeadcafe59", 8, { simulate: true });
-        expect(res.result).toBe("0x00deadcafe");
+        expect(res.result[0]).toBe("0x00deadcafe");
         res = await token.functions.op_u8_5(8, "0xdeadcafe59", "0x0000000006", { simulate: true });
-        expect(res.result).toBe("0xdeadcafe5f");
+        expect(res.result[0]).toBe("0xdeadcafe5f");
         res = await token.functions.op_u8_5(9, "0xdeadcafe59", "0x00000000ff", { simulate: true });
-        expect(res.result).toBe("0x0000000059");
+        expect(res.result[0]).toBe("0x0000000059");
         res = await token.functions.op_u8_5(10, "0xdeadcafe59", "0x00000000ff", { simulate: true });
-        expect(res.result).toBe("0xdeadcafea6");
+        expect(res.result[0]).toBe("0xdeadcafea6");
 
         // TEST bytes14
         res = await token.functions.op_u8_14_shift(6, "0xdeadcafe123456789abcdefbeef7", "9", { simulate: true });
-        expect(res.result).toBe("0x5b95fc2468acf13579bdf7ddee00");
+        expect(res.result[0]).toBe("0x5b95fc2468acf13579bdf7ddee00");
         res = await token.functions.op_u8_14_shift(7, "0xdeadcafe123456789abcdefbeef7", "9", { simulate: true });
-        expect(res.result).toBe("0x006f56e57f091a2b3c4d5e6f7df7");
+        expect(res.result[0]).toBe("0x006f56e57f091a2b3c4d5e6f7df7");
         res = await token.functions.op_u8_14(8, "0xdeadcafe123456789abcdefbeef7", "0x0000060000000000000000000000", { simulate: true });
-        expect(res.result).toBe("0xdeadcefe123456789abcdefbeef7");
+        expect(res.result[0]).toBe("0xdeadcefe123456789abcdefbeef7");
         res = await token.functions.op_u8_14(9, "0xdeadcafe123456789abcdefbeef7", "0x000000000000000000ff00000000", { simulate: true });
-        expect(res.result).toBe("0x000000000000000000bc00000000");
+        expect(res.result[0]).toBe("0x000000000000000000bc00000000");
         res = await token.functions.op_u8_14(10, "0xdeadcafe123456789abcdefbeef7", "0xff00000000000000000000000000", { simulate: true });
-        expect(res.result).toBe("0x21adcafe123456789abcdefbeef7");
+        expect(res.result[0]).toBe("0x21adcafe123456789abcdefbeef7");
 
         // TEST address type. We need to encoding this has a hex string with the '0x' prefix, since solang maps address
         // to bytes32 type
         let address = '0x' + payerAccount.publicKey.toBuffer().toString('hex');
         res = await token.functions.address_passthrough(address);
-        expect(res.result).toBe(address);
+        expect(res.result[0]).toBe(address);
     });
 
     it('store', async function () {
@@ -176,7 +176,7 @@ describe('Deploy solang contract and test', () => {
         for (let i = 0; i < 20; i++) {
             res = await token.functions.get_bs({ simulate: true });
 
-            expect(res.result).toStrictEqual(bs);
+            expect(res.result).toStrictEqual([bs]);
 
             if (bs.length <= 4 || Math.random() >= 0.5) {
                 let val = ((Math.random() * 256) | 0).toString(16);
@@ -414,7 +414,7 @@ describe('Deploy solang contract and test', () => {
 
             res = await token.functions.hasPermission(user[2], p, { simulate: true });
 
-            expect(res.result).toBe(true);
+            expect(res.result).toStrictEqual([true]);
         }
 
         user = users[Math.floor(Math.random() * users.length)];
@@ -427,6 +427,6 @@ describe('Deploy solang contract and test', () => {
 
         res = await token.functions.userExists(user[2]);
 
-        expect(res.result).toBe(false);
+        expect(res.result).toStrictEqual([false]);
     });
 });

integration/solana/utils.ts

@@ -1,64 +1,50 @@
 
-import { Connection, Keypair } from '@solana/web3.js';
-import { Contract, Program } from '@solana/solidity';
+import { Connection, Keypair, LAMPORTS_PER_SOL } from '@solana/web3.js';
+import { Contract } from '@solana/solidity';
 import fs from 'fs';
 
 
 const endpoint: string = process.env.RPC_URL || "http://localhost:8899";
 const PROGRAM_SO: Buffer = fs.readFileSync('bundle.so');
+let program_id: Keypair | undefined = undefined;
 
-export async function loadContract(name: string, abifile: string, args: any[] = [], space: number = 8192): Promise<[Contract, Connection, Keypair]> {
-    const CONTRACT_ABI: string = fs.readFileSync(abifile, 'utf8');
+export async function loadContract(name: string, abifile: string, args: any[] = [], space: number = 8192): Promise<[Contract, Connection, Keypair, Keypair]> {
+    const abi = JSON.parse(fs.readFileSync(abifile, 'utf8'));
 
     const connection = new Connection(endpoint, 'confirmed');
 
     const payerAccount = await newAccountWithLamports(connection, 10000000000);
-    const program = await Program.load(connection, payerAccount, Keypair.generate(), PROGRAM_SO);
-
-    const storageKeyPair = Keypair.generate();
-    const deployRes = await program.deployContract({
-        name,
-        abi: CONTRACT_ABI,
-        storageKeyPair,
-        constructorArgs: args,
-        space
-    });
-
-    return [deployRes.contract, connection, payerAccount];
+    const program = Keypair.generate();
+    const storage = Keypair.generate();
+    const contract = new Contract(connection, program.publicKey, storage.publicKey, abi, payerAccount);
+
+    await contract.load(program, PROGRAM_SO);
+
+    await contract.deploy(name, args, program, storage, space);
+
+    return [contract, connection, payerAccount, program];
 }
 
-export async function loadProgram(): Promise<[Program, Connection, Keypair]> {
-    const connection = new Connection(endpoint, 'confirmed');
+export async function load2ndContract(connection: Connection, program: Keypair, payerAccount: Keypair, name: string, abifile: string, args: any[] = [], space: number = 8192): Promise<Contract> {
+    const abi = JSON.parse(fs.readFileSync(abifile, 'utf8'));
 
-    const payerAccount = await newAccountWithLamports(connection, 10000000000);
-    const program = await Program.load(connection, payerAccount, Keypair.generate(), PROGRAM_SO);
+    const storage = Keypair.generate();
+    const contract = new Contract(connection, program.publicKey, storage.publicKey, abi, payerAccount);
+
+    await contract.deploy(name, args, program, storage, space);
 
-    return [program, connection, payerAccount];
+    return contract;
 }
 
 async function newAccountWithLamports(
     connection: Connection,
-    lamports: number = 10000000000
+    lamports: number = LAMPORTS_PER_SOL
 ): Promise<Keypair> {
     const account = Keypair.generate();
 
-    let retries = 10;
-    await connection.requestAirdrop(account.publicKey, lamports);
-    for (; ;) {
-        await sleep(500);
-        if (lamports == (await connection.getBalance(account.publicKey))) {
-            return account;
-        }
-        if (--retries <= 0) {
-            break;
-        }
-        // console.log('airdrop retry ' + retries);
-    }
-    throw new Error(`airdrop of ${lamports} failed`);
-}
+    console.log('Airdropping SOL to a new wallet ...');
+    const signature = await connection.requestAirdrop(account.publicKey, lamports);
+    await connection.confirmTransaction(signature, 'confirmed');
 
-function sleep(ms: number) {
-    return new Promise(function (resolve) {
-        setTimeout(resolve, ms);
-    });
-}
+    return account;
+}