265 lines
8.5 KiB
JavaScript
265 lines
8.5 KiB
JavaScript
const anchor = require("@coral-xyz/anchor");
|
|
const { assert } = require("chai");
|
|
const nativeAssert = require("assert");
|
|
const PublicKey = anchor.web3.PublicKey;
|
|
const BN = anchor.BN;
|
|
|
|
describe("zero-copy", () => {
|
|
// Configure the client to use the local cluster.
|
|
anchor.setProvider(anchor.AnchorProvider.env());
|
|
|
|
const program = anchor.workspace.ZeroCopy;
|
|
const programCpi = anchor.workspace.ZeroCpi;
|
|
|
|
const foo = anchor.web3.Keypair.generate();
|
|
it("Is creates a zero copy account", async () => {
|
|
await program.rpc.createFoo({
|
|
accounts: {
|
|
foo: foo.publicKey,
|
|
authority: program.provider.wallet.publicKey,
|
|
rent: anchor.web3.SYSVAR_RENT_PUBKEY,
|
|
},
|
|
instructions: [await program.account.foo.createInstruction(foo)],
|
|
signers: [foo],
|
|
});
|
|
const account = await program.account.foo.fetch(foo.publicKey);
|
|
assert.strictEqual(
|
|
JSON.stringify(account.authority.toBuffer()),
|
|
JSON.stringify(program.provider.wallet.publicKey.toBuffer())
|
|
);
|
|
assert.strictEqual(account.data.toNumber(), 0);
|
|
assert.strictEqual(account.secondData.toNumber(), 0);
|
|
assert.strictEqual(
|
|
JSON.stringify(account.secondAuthority),
|
|
JSON.stringify([...program.provider.wallet.publicKey.toBuffer()])
|
|
);
|
|
});
|
|
|
|
it("Updates a zero copy account field", async () => {
|
|
await program.rpc.updateFoo(new BN(1234), {
|
|
accounts: {
|
|
foo: foo.publicKey,
|
|
authority: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
|
|
const account = await program.account.foo.fetch(foo.publicKey);
|
|
|
|
assert.strictEqual(
|
|
JSON.stringify(account.authority.toBuffer()),
|
|
JSON.stringify(program.provider.wallet.publicKey.toBuffer())
|
|
);
|
|
assert.strictEqual(account.data.toNumber(), 1234);
|
|
assert.strictEqual(account.secondData.toNumber(), 0);
|
|
assert.strictEqual(
|
|
JSON.stringify(account.secondAuthority),
|
|
JSON.stringify([...program.provider.wallet.publicKey.toBuffer()])
|
|
);
|
|
});
|
|
|
|
it("Updates a a second zero copy account field", async () => {
|
|
await program.rpc.updateFooSecond(new BN(55), {
|
|
accounts: {
|
|
foo: foo.publicKey,
|
|
secondAuthority: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
|
|
const account = await program.account.foo.fetch(foo.publicKey);
|
|
|
|
assert.strictEqual(
|
|
JSON.stringify(account.authority.toBuffer()),
|
|
JSON.stringify(program.provider.wallet.publicKey.toBuffer())
|
|
);
|
|
assert.strictEqual(account.data.toNumber(), 1234);
|
|
assert.strictEqual(account.secondData.toNumber(), 55);
|
|
assert.strictEqual(
|
|
JSON.stringify(account.secondAuthority),
|
|
JSON.stringify([...program.provider.wallet.publicKey.toBuffer()])
|
|
);
|
|
});
|
|
|
|
it("Creates an associated zero copy account", async () => {
|
|
await program.rpc.createBar({
|
|
accounts: {
|
|
bar: (
|
|
await PublicKey.findProgramAddress(
|
|
[
|
|
program.provider.wallet.publicKey.toBuffer(),
|
|
foo.publicKey.toBuffer(),
|
|
],
|
|
program.programId
|
|
)
|
|
)[0],
|
|
authority: program.provider.wallet.publicKey,
|
|
foo: foo.publicKey,
|
|
systemProgram: anchor.web3.SystemProgram.programId,
|
|
},
|
|
});
|
|
|
|
const bar = (
|
|
await PublicKey.findProgramAddress(
|
|
[
|
|
program.provider.wallet.publicKey.toBuffer(),
|
|
foo.publicKey.toBuffer(),
|
|
],
|
|
program.programId
|
|
)
|
|
)[0];
|
|
const barAccount = await program.account.bar.fetch(bar);
|
|
assert.isTrue(
|
|
barAccount.authority.equals(program.provider.wallet.publicKey)
|
|
);
|
|
assert.strictEqual(barAccount.data.toNumber(), 0);
|
|
});
|
|
|
|
it("Updates an associated zero copy account", async () => {
|
|
const bar = (
|
|
await PublicKey.findProgramAddress(
|
|
[
|
|
program.provider.wallet.publicKey.toBuffer(),
|
|
foo.publicKey.toBuffer(),
|
|
],
|
|
program.programId
|
|
)
|
|
)[0];
|
|
await program.rpc.updateBar(new BN(99), {
|
|
accounts: {
|
|
bar,
|
|
authority: program.provider.wallet.publicKey,
|
|
foo: foo.publicKey,
|
|
},
|
|
});
|
|
const barAccount = await program.account.bar.fetch(bar);
|
|
assert.isTrue(
|
|
barAccount.authority.equals(program.provider.wallet.publicKey)
|
|
);
|
|
assert.strictEqual(barAccount.data.toNumber(), 99);
|
|
// Check zero_copy CPI
|
|
await programCpi.rpc.checkCpi(new BN(1337), {
|
|
accounts: {
|
|
bar,
|
|
authority: program.provider.wallet.publicKey,
|
|
foo: foo.publicKey,
|
|
zeroCopyProgram: program.programId,
|
|
},
|
|
});
|
|
const barAccountAfterCpi = await program.account.bar.fetch(bar);
|
|
assert.isTrue(
|
|
barAccountAfterCpi.authority.equals(program.provider.wallet.publicKey)
|
|
);
|
|
assert.strictEqual(barAccountAfterCpi.data.toNumber(), 1337);
|
|
});
|
|
|
|
const eventQ = anchor.web3.Keypair.generate();
|
|
const size = 1000000 + 8; // Account size in bytes.
|
|
|
|
it("Creates a large event queue", async () => {
|
|
await program.rpc.createLargeAccount({
|
|
accounts: {
|
|
eventQ: eventQ.publicKey,
|
|
rent: anchor.web3.SYSVAR_RENT_PUBKEY,
|
|
},
|
|
instructions: [
|
|
await program.account.eventQ.createInstruction(eventQ, size),
|
|
],
|
|
signers: [eventQ],
|
|
});
|
|
const account = await program.account.eventQ.fetch(eventQ.publicKey);
|
|
assert.strictEqual(account.events.length, 25000);
|
|
account.events.forEach((event) => {
|
|
assert.isTrue(event.from.equals(PublicKey.default));
|
|
assert.strictEqual(event.data.toNumber(), 0);
|
|
});
|
|
});
|
|
|
|
it("Updates a large event queue", async () => {
|
|
// Set index 0.
|
|
await program.rpc.updateLargeAccount(0, new BN(48), {
|
|
accounts: {
|
|
eventQ: eventQ.publicKey,
|
|
from: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
// Verify update.
|
|
let account = await program.account.eventQ.fetch(eventQ.publicKey);
|
|
assert.strictEqual(account.events.length, 25000);
|
|
account.events.forEach((event, idx) => {
|
|
if (idx === 0) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 48);
|
|
} else {
|
|
assert.isTrue(event.from.equals(PublicKey.default));
|
|
assert.strictEqual(event.data.toNumber(), 0);
|
|
}
|
|
});
|
|
|
|
// Set index 11111.
|
|
await program.rpc.updateLargeAccount(11111, new BN(1234), {
|
|
accounts: {
|
|
eventQ: eventQ.publicKey,
|
|
from: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
// Verify update.
|
|
account = await program.account.eventQ.fetch(eventQ.publicKey);
|
|
assert.strictEqual(account.events.length, 25000);
|
|
account.events.forEach((event, idx) => {
|
|
if (idx === 0) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 48);
|
|
} else if (idx === 11111) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 1234);
|
|
} else {
|
|
assert.isTrue(event.from.equals(PublicKey.default));
|
|
assert.strictEqual(event.data.toNumber(), 0);
|
|
}
|
|
});
|
|
|
|
// Set last index.
|
|
await program.rpc.updateLargeAccount(24999, new BN(99), {
|
|
accounts: {
|
|
eventQ: eventQ.publicKey,
|
|
from: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
// Verify update.
|
|
account = await program.account.eventQ.fetch(eventQ.publicKey);
|
|
assert.strictEqual(account.events.length, 25000);
|
|
account.events.forEach((event, idx) => {
|
|
if (idx === 0) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 48);
|
|
} else if (idx === 11111) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 1234);
|
|
} else if (idx === 24999) {
|
|
assert.isTrue(event.from.equals(program.provider.wallet.publicKey));
|
|
assert.strictEqual(event.data.toNumber(), 99);
|
|
} else {
|
|
assert.isTrue(event.from.equals(PublicKey.default));
|
|
assert.strictEqual(event.data.toNumber(), 0);
|
|
}
|
|
});
|
|
});
|
|
|
|
it("Errors when setting an out of bounds index", async () => {
|
|
// Fail to set non existing index.
|
|
await nativeAssert.rejects(
|
|
async () => {
|
|
await program.rpc.updateLargeAccount(25000, new BN(1), {
|
|
accounts: {
|
|
eventQ: eventQ.publicKey,
|
|
from: program.provider.wallet.publicKey,
|
|
},
|
|
});
|
|
},
|
|
(err) => {
|
|
console.log("err", err);
|
|
return true;
|
|
}
|
|
);
|
|
});
|
|
});
|