;
13 |
14 | const counterKeypair = Keypair.generate();
15 | const counterZeroCopyKeypair = Keypair.generate();
16 |
17 | it('Initialize Counter', async () => {
18 | const sig = await program.methods
19 | .initialize()
20 | .accounts({
21 | counter: counterKeypair.publicKey,
22 | payer: payer.publicKey,
23 | })
24 | .signers([counterKeypair])
25 | .rpc();
26 |
27 | console.log('Init counter ' + sig);
28 | });
29 |
30 | it('Initialize Counter Zero Copy', async () => {
31 | const sig = await program.methods
32 | .initializeZeroCopy()
33 | .accounts({
34 | counterZeroCopy: counterZeroCopyKeypair.publicKey,
35 | payer: payer.publicKey,
36 | })
37 | .signers([counterZeroCopyKeypair])
38 | .rpc();
39 |
40 | console.log('Init counter zero copy ' + sig);
41 | });
42 |
43 | it('Increment Counter', async () => {
44 | const sim = await program.methods
45 | .increment()
46 | .accounts({
47 | counter: counterKeypair.publicKey,
48 | })
49 | .simulate();
50 |
51 | console.log('Increment counter ' + JSON.stringify(sim));
52 |
53 | const sig = await program.methods
54 | .increment()
55 | .accounts({
56 | counter: counterKeypair.publicKey,
57 | })
58 | .rpc();
59 |
60 | console.log('Increment counter ' + sig);
61 |
62 | const currentCount = await program.account.counterData.fetch(
63 | counterKeypair.publicKey,
64 | );
65 | console.log('Current count ' + currentCount.count.toNumber());
66 | });
67 |
68 | it('Increment Counter zero copy', async () => {
69 | const sim = await program.methods
70 | .incrementZeroCopy()
71 | .accounts({ counterZeroCopy: counterZeroCopyKeypair.publicKey })
72 | .simulate();
73 | console.log('Increment counter zero copy ' + JSON.stringify(sim));
74 |
75 | const sig = await program.methods
76 | .incrementZeroCopy()
77 | .accounts({ counterZeroCopy: counterZeroCopyKeypair.publicKey })
78 | .rpc({ skipPreflight: true });
79 | console.log('Increment counter zero copy ' + sig);
80 |
81 | const currentCount = await program.account.counterZeroCopy.fetch(
82 | counterZeroCopyKeypair.publicKey,
83 | );
84 | console.log('Current count ' + currentCount.count.toNumber());
85 | });
86 |
87 | it('Allocations', async () => {
88 | const sig = await program.methods
89 | .allocations()
90 | .accounts({ counter: counterKeypair.publicKey })
91 | .simulate();
92 |
93 | console.log('Allocations ' + JSON.stringify(sig));
94 | });
95 |
96 | it('Closure and Function calls', async () => {
97 | const sim = await program.methods
98 | .incrementWithFnCall()
99 | .accounts({ counter: counterKeypair.publicKey })
100 | .simulate();
101 |
102 | console.log('Closure and Function calls ' + JSON.stringify(sim));
103 | });
104 |
105 | it('Set counter value u64', async () => {
106 | const sim = await program.methods
107 | .setBigData(new anchor.BN(42))
108 | .accounts({ counter: counterKeypair.publicKey })
109 | .simulate();
110 |
111 | console.log('Set value u64: ' + JSON.stringify(sim));
112 |
113 | await program.methods
114 | .setBigData(new anchor.BN(42))
115 | .accounts({ counter: counterKeypair.publicKey })
116 | .rpc();
117 |
118 | const currentCount = await program.account.counterData.fetch(
119 | counterKeypair.publicKey,
120 | );
121 |
122 | expect(currentCount.count.toNumber()).toEqual(42);
123 | });
124 |
125 | it('Set counter value u8', async () => {
126 | const sim = await program.methods
127 | .setSmallData(42)
128 | .accounts({ counter: counterKeypair.publicKey })
129 | .simulate();
130 |
131 | console.log('Set value u8: ' + JSON.stringify(sim));
132 |
133 | await program.methods
134 | .setSmallData(42)
135 | .accounts({ counter: counterKeypair.publicKey })
136 | .rpc();
137 |
138 | const currentCount = await program.account.counterData.fetch(
139 | counterKeypair.publicKey,
140 | );
141 |
142 | expect(currentCount.count.toNumber()).toEqual(42);
143 | });
144 |
145 | it('CPI', async () => {
146 | const sim = await program.methods
147 | .doCpi(new anchor.BN(1))
148 | .accounts({ counter: counterKeypair.publicKey })
149 | .simulate();
150 |
151 | console.log('Do Cpi: ' + JSON.stringify(sim));
152 |
153 | const sig = await program.methods
154 | .doCpi(new anchor.BN(1))
155 | .accounts({ counter: counterKeypair.publicKey })
156 | .rpc({ skipPreflight: true });
157 | console.log('Do CPI ' + sig);
158 | });
159 |
160 | it('PDAS', async () => {
161 | const counter_checked = PublicKey.findProgramAddressSync(
162 | [Buffer.from('counter')],
163 | program.programId,
164 | );
165 |
166 | const init_sig = await program.methods
167 | .initPdaWithSeed()
168 | .accounts({
169 | })
170 | .rpc({ skipPreflight: true });
171 | console.log('Init Pda with seed ' + init_sig);
172 |
173 | const sim = await program.methods
174 | .pdas()
175 | .accounts({
176 | counter: counterKeypair.publicKey,
177 | })
178 | .simulate();
179 |
180 | console.log('PDAS: ' + JSON.stringify(sim));
181 |
182 | const sig = await program.methods
183 | .pdas()
184 | .accounts({
185 | counter: counterKeypair.publicKey,
186 | })
187 | .rpc({ skipPreflight: true });
188 | console.log('PDAS ' + sig);
189 | });
190 |
191 | it('Checked Math', async () => {
192 | const sim = await program.methods
193 | .checkedMathTest()
194 | .accounts({
195 | counter: counterKeypair.publicKey,
196 | })
197 | .simulate();
198 |
199 | console.log('Calculations ' + JSON.stringify(sim));
200 |
201 | const sig = await program.methods
202 | .checkedMathTest()
203 | .accounts({
204 | counter: counterKeypair.publicKey,
205 | })
206 | .rpc();
207 |
208 | console.log('mulVsDiv ' + sig);
209 | });
210 |
211 | it('Clone variables', async () => {
212 | const sim = await program.methods
213 | .cloneVariables()
214 | .accounts({
215 | counter: counterKeypair.publicKey,
216 | })
217 | .simulate();
218 |
219 | console.log('cloneVariables ' + JSON.stringify(sim));
220 |
221 | const sig = await program.methods
222 | .cloneVariables()
223 | .accounts({
224 | counter: counterKeypair.publicKey,
225 | })
226 | .rpc();
227 |
228 | console.log('cloneVariables ' + sig);
229 | });
230 | });
231 |
--------------------------------------------------------------------------------
/counterAnchor/web/components/account/account-ui.tsx:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useWallet } from '@solana/wallet-adapter-react';
4 | import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
5 | import { IconRefresh } from '@tabler/icons-react';
6 | import { useQueryClient } from '@tanstack/react-query';
7 | import { useMemo, useState } from 'react';
8 | import { AppModal, ellipsify } from '../ui/ui-layout';
9 | import { useCluster } from '../cluster/cluster-data-access';
10 | import { ExplorerLink } from '../cluster/cluster-ui';
11 | import {
12 | useGetBalance,
13 | useGetSignatures,
14 | useGetTokenAccounts,
15 | useRequestAirdrop,
16 | useTransferSol,
17 | } from './account-data-access';
18 |
19 | export function AccountBalance({ address }: { address: PublicKey }) {
20 | const query = useGetBalance({ address });
21 |
22 | return (
23 |
24 |
query.refetch()}
27 | >
28 | {query.data ? : '...'} SOL
29 |
30 |
31 | );
32 | }
33 | export function AccountChecker() {
34 | const { publicKey } = useWallet();
35 | if (!publicKey) {
36 | return null;
37 | }
38 | return ;
39 | }
40 | export function AccountBalanceCheck({ address }: { address: PublicKey }) {
41 | const { cluster } = useCluster();
42 | const mutation = useRequestAirdrop({ address });
43 | const query = useGetBalance({ address });
44 |
45 | if (query.isLoading) {
46 | return null;
47 | }
48 | if (query.isError || !query.data) {
49 | return (
50 |
51 |
52 | You are connected to {cluster.name} but your account
53 | is not found on this cluster.
54 |
55 |
63 |
64 | );
65 | }
66 | return null;
67 | }
68 |
69 | export function AccountButtons({ address }: { address: PublicKey }) {
70 | const wallet = useWallet();
71 | const { cluster } = useCluster();
72 | const [showAirdropModal, setShowAirdropModal] = useState(false);
73 | const [showReceiveModal, setShowReceiveModal] = useState(false);
74 | const [showSendModal, setShowSendModal] = useState(false);
75 |
76 | return (
77 |
78 |
setShowAirdropModal(false)}
80 | address={address}
81 | show={showAirdropModal}
82 | />
83 | setShowReceiveModal(false)}
87 | />
88 | setShowSendModal(false)}
92 | />
93 |
94 |
101 |
108 |
114 |
115 |
130 |
131 |
132 |
Token Accounts
133 |
134 | {query.isLoading ? (
135 |
136 | ) : (
137 |
148 | )}
149 |
150 |
151 |
152 | {query.isError && (
153 |
154 | Error: {query.error?.message.toString()}
155 |
156 | )}
157 | {query.isSuccess && (
158 |
159 | {query.data.length === 0 ? (
160 |
No token accounts found.
161 | ) : (
162 |
163 |
164 |
165 | | Public Key |
166 | Mint |
167 | Balance |
168 |
169 |
170 |
171 | {items?.map(({ account, pubkey }) => (
172 |
173 | |
174 |
175 |
176 |
180 |
181 |
182 | |
183 |
184 |
185 |
186 |
190 |
191 |
192 | |
193 |
194 |
195 | {account.data.parsed.info.tokenAmount.uiAmount}
196 |
197 | |
198 |
199 | ))}
200 |
201 | {(query.data?.length ?? 0) > 5 && (
202 |
203 | |
204 |
210 | |
211 |
212 | )}
213 |
214 |
215 | )}
216 |
217 | )}
218 |
233 |
234 |
Transaction History
235 |
236 | {query.isLoading ? (
237 |
238 | ) : (
239 |
245 | )}
246 |
247 |
248 | {query.isError && (
249 |
250 | Error: {query.error?.message.toString()}
251 |
252 | )}
253 | {query.isSuccess && (
254 |
255 | {query.data.length === 0 ? (
256 |
No transactions found.
257 | ) : (
258 |
259 |
260 |
261 | | Signature |
262 | Slot |
263 | Block Time |
264 | Status |
265 |
266 |
267 |
268 | {items?.map((item) => (
269 |
270 | |
271 |
275 | |
276 |
277 |
281 | |
282 |
283 | {new Date((item.blockTime ?? 0) * 1000).toISOString()}
284 | |
285 |
286 | {item.err ? (
287 |
291 | Failed
292 |
293 | ) : (
294 | Success
295 | )}
296 | |
297 |
298 | ))}
299 | {(query.data?.length ?? 0) > 5 && (
300 |
301 | |
302 |
308 | |
309 |
310 | )}
311 |
312 |
313 | )}
314 |
315 | )}
316 |
Receive assets by sending them to your public key:
338 | {address.toString()}
339 |
340 | );
341 | }
342 |
343 | function ModalAirdrop({
344 | hide,
345 | show,
346 | address,
347 | }: {
348 | hide: () => void;
349 | show: boolean;
350 | address: PublicKey;
351 | }) {
352 | const mutation = useRequestAirdrop({ address });
353 | const [amount, setAmount] = useState('2');
354 |
355 | return (
356 | mutation.mutateAsync(parseFloat(amount)).then(() => hide())}
363 | >
364 | setAmount(e.target.value)}
373 | />
374 |
375 | );
376 | }
377 |
378 | function ModalSend({
379 | hide,
380 | show,
381 | address,
382 | }: {
383 | hide: () => void;
384 | show: boolean;
385 | address: PublicKey;
386 | }) {
387 | const wallet = useWallet();
388 | const mutation = useTransferSol({ address });
389 | const [destination, setDestination] = useState('');
390 | const [amount, setAmount] = useState('1');
391 |
392 | if (!address || !wallet.sendTransaction) {
393 | return Wallet not connected
;
394 | }
395 |
396 | return (
397 | {
404 | mutation
405 | .mutateAsync({
406 | destination: new PublicKey(destination),
407 | amount: parseFloat(amount),
408 | })
409 | .then(() => hide());
410 | }}
411 | >
412 | setDestination(e.target.value)}
419 | />
420 | setAmount(e.target.value)}
429 | />
430 |
431 | );
432 | }
433 |
--------------------------------------------------------------------------------
/counterAnchor/anchor/programs/counter/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![allow(clippy::result_large_err)]
2 |
3 | use anchor_lang::prelude::*;
4 | use bytemuck::{ Pod, Zeroable };
5 |
6 | declare_id!("5N5E4imUxwwdbYZern6xzKXejuHy3jNprfrvVmzT3YdF");
7 |
8 | #[macro_export]
9 | #[cfg(not(feature = "trace-compute"))]
10 | macro_rules! compute {
11 | (
12 | $msg:expr => $($tt:tt)*
13 | ) => { $($tt)* };
14 | }
15 |
16 | /// Total extra compute units used per compute_fn! call 409 CU
17 | /// https://github.com/anza-xyz/agave/blob/d88050cda335f87e872eddbdf8506bc063f039d3/programs/bpf_loader/src/syscalls/logging.rs#L70
18 | /// https://github.com/anza-xyz/agave/blob/d88050cda335f87e872eddbdf8506bc063f039d3/program-runtime/src/compute_budget.rs#L150
19 | #[macro_export]
20 | macro_rules! compute_fn {
21 | (
22 | $msg:expr => $($tt:tt)*
23 | ) => {
24 | ::solana_program::msg!(concat!($msg, " {"));
25 | ::solana_program::log::sol_log_compute_units();
26 | let res = { $($tt)* };
27 | ::solana_program::log::sol_log_compute_units();
28 | ::solana_program::msg!(concat!(" } // ", $msg));
29 | res
30 | };
31 | }
32 |
33 | #[program]
34 | pub mod counter {
35 | use anchor_lang::system_program;
36 | use std::str::FromStr;
37 |
38 | use super::*;
39 |
40 | // Total 19241 CU
41 | pub fn allocations(ctx: Context) -> Result<()> {
42 | // 109 CU
43 | compute_fn! { "increase u8" =>
44 | ctx.accounts.counter.count += 1;
45 | }
46 |
47 | // 204
48 | compute_fn! { "Log a string " =>
49 | msg!("Compute units");
50 | }
51 |
52 | // 11962 CU !!
53 | // Base58 encoding is expensive, concatenation is expensive
54 | compute_fn! { "Log a pubkey to account info" =>
55 | msg!("A string {0}", ctx.accounts.counter.to_account_info().key());
56 | }
57 |
58 | // 262 cu
59 | compute_fn! { "Log a pubkey" =>
60 | ctx.accounts.counter.to_account_info().key().log();
61 | }
62 |
63 | let pubkey = ctx.accounts.counter.to_account_info().key();
64 |
65 | // 206 CU
66 | compute_fn! { "Pubkey.log" =>
67 | pubkey.log();
68 | }
69 |
70 | // 357 CU - string concatenation is expensive
71 | compute_fn! { "Log a pubkey simple concat" =>
72 | msg!("A string {0}", "5w6z5PWvtkCd4PaAV7avxE6Fy5brhZsFdbRLMt8UefRQ");
73 | }
74 |
75 | // 357
76 | compute_fn! { "Push Vector u64 " =>
77 | let mut a: Vec = Vec::new();
78 | a.push(1);
79 | a.push(1);
80 | a.push(1);
81 | a.push(1);
82 | a.push(1);
83 | a.push(1);
84 | }
85 |
86 | // 125 CU
87 | compute_fn! { "Vector u64 init" =>
88 | let _a: Vec = vec![1, 1, 1, 1, 1, 1];
89 | }
90 |
91 | // 356 CU
92 | compute_fn! { "Vector i64 " =>
93 | // this costs 356 CU (takes the same space as u64)
94 | let mut a: Vec = Vec::new();
95 | a.push(1);
96 | a.push(1);
97 | a.push(1);
98 | a.push(1);
99 | a.push(1);
100 | a.push(1);
101 | }
102 |
103 | // 211 CU
104 | compute_fn! { "Vector u8 " =>
105 | let mut a: Vec = Vec::new();
106 | a.push(1);
107 | a.push(1);
108 | a.push(1);
109 | a.push(1);
110 | a.push(1);
111 | a.push(1);
112 | }
113 |
114 | Ok(())
115 | }
116 |
117 | // Total 14742 CU
118 | pub fn increment(ctx: Context) -> Result<()> {
119 | // There seems to not be any difference in between different ways of using checked_add
120 | let counter = &mut ctx.accounts.counter;
121 |
122 | // 3405 CU
123 | compute_fn! { "counter checked_add.unwrap()" =>
124 | for _ in 0..254 {
125 | counter.count = counter.count.checked_add(1).unwrap();
126 | }
127 | }
128 | counter.count = 0;
129 |
130 | // 3404 CU
131 | compute_fn! { "counter checked_add()" =>
132 | for _ in 0..254 {
133 | match counter.count.checked_add(1) {
134 | Some(v) => counter.count = v,
135 | None => panic!("overflow"),
136 | }
137 | }
138 | }
139 | counter.count = 0;
140 |
141 | // 3404 CU
142 | compute_fn! { "counter += 1" =>
143 | for _ in 0..254 {
144 | counter.count += 1;
145 | }
146 | }
147 |
148 | Ok(())
149 | }
150 |
151 | // Total 16058 CU - there seem to be no big speed differences here. Surprisingly the function version is cheapest
152 | pub fn increment_with_fn_call(ctx: Context) -> Result<()> {
153 | let closure = |x: u64| -> u64 { x + 1 };
154 |
155 | // 3913 CU
156 | compute_fn! { "counter with closure call" =>
157 | for _ in 0..254 {
158 | ctx.accounts.counter.count = closure(ctx.accounts.counter.count);
159 | }
160 | }
161 | msg!("Counter: {}", ctx.accounts.counter.count);
162 |
163 | // 3660 CU
164 | compute_fn! { "counter with function call" =>
165 | for _ in 0..254 {
166 | ctx.accounts.counter.count = increase_counter_function(ctx.accounts.counter.count);
167 | }
168 | }
169 | msg!("Counter: {}", ctx.accounts.counter.count);
170 |
171 | // 3914 CU
172 | compute_fn! { "inline " =>
173 | for _ in 0..254 {
174 | ctx.accounts.counter.count += 1;
175 | }
176 | }
177 | msg!("Counter: {}", ctx.accounts.counter.count);
178 |
179 | Ok(())
180 | }
181 |
182 | // Total 13496 CU - There seems to be no speed improvements here
183 | pub fn increment_zero_copy(ctx: Context) -> Result<()> {
184 | let mut counter = ctx.accounts.counter_zero_copy.load_mut()?;
185 |
186 | // 3912 CU
187 | compute_fn! { "counter checked_add.unwrap()" =>
188 | for _ in 0..254 {
189 | counter.count = counter.count.checked_add(1).unwrap();
190 | }
191 | }
192 | counter.count = 0;
193 |
194 | // 3912 CU
195 | compute_fn! { "counter checked_add()" =>
196 | for _ in 0..254 {
197 | match counter.count.checked_add(1) {
198 | Some(v) => counter.count = v,
199 | None => panic!("overflow"),
200 | }
201 | }
202 | }
203 | counter.count = 0;
204 |
205 | // 3912 CU
206 | compute_fn! { "counter += 1" =>
207 | for _ in 0..254 {
208 | counter.count += 1;
209 | }
210 | }
211 | Ok(())
212 | }
213 |
214 | // 6302 CU
215 | pub fn initialize(_ctx: Context) -> Result<()> {
216 | Ok(())
217 | }
218 |
219 | // 5020 CU
220 | pub fn initialize_zero_copy(_ctx: Context) -> Result<()> {
221 | Ok(())
222 | }
223 |
224 | // Total 946 CU
225 | pub fn set_big_data(ctx: Context, _data: u64) -> Result<()> {
226 | ctx.accounts.counter.count = _data;
227 | Ok(())
228 | }
229 |
230 | // Total 945 CU
231 | pub fn set_small_data(ctx: Context, _data: u8) -> Result<()> {
232 | ctx.accounts.counter.count = _data as u64;
233 | Ok(())
234 | }
235 |
236 | pub fn init_pda_with_seed(ctx: Context) -> Result<()> {
237 | ctx.accounts.counter_checked.bump = ctx.bumps.counter_checked;
238 | Ok(())
239 | }
240 |
241 | // Total 24985 CU - with the anchor checks for account_checked it becomes 38135 CU so the seeds check is around 12000 CU
242 | // which is not bad, but could be better.
243 | // If you instead use the bump that is saved in the counter_checked account it becomes 27859 CU so the overhead of the check is only 3000 CU
244 | pub fn pdas(ctx: Context) -> Result<()> {
245 | let program_id = Pubkey::from_str("5w6z5PWvtkCd4PaAV7avxE6Fy5brhZsFdbRLMt8UefRQ").unwrap();
246 |
247 | // 12,136 CUs
248 | compute_fn! { "Find PDA" =>
249 | Pubkey::find_program_address(&[b"counter"], ctx.program_id);
250 | }
251 |
252 | // 1,651 CUs
253 | compute_fn! { "Find PDA" =>
254 | Pubkey::create_program_address(&[b"counter", &[248_u8]], &program_id).unwrap();
255 | }
256 |
257 | Ok(())
258 | }
259 |
260 | // Total 5787 CU
261 | pub fn do_cpi(ctx: Context, _data: u64) -> Result<()> {
262 | // 2,215 CUs
263 | compute_fn! { "CPI system program" =>
264 | let cpi_context = CpiContext::new(
265 | ctx.accounts.system_program.to_account_info(),
266 | system_program::Transfer {
267 | from: ctx.accounts.payer.to_account_info().clone(),
268 | to: ctx.accounts.counter.to_account_info().clone(),
269 | },
270 | );
271 | system_program::transfer(cpi_context, 1)?;
272 | }
273 |
274 | // 251 CUs. In an error case though the whole transactions is 1,199 CUs bigger than without. So error handling is expensive
275 | compute_fn! { "Transfer borrowing lamports" =>
276 | let counter_account_info = ctx.accounts.counter.to_account_info();
277 | let mut source_lamports = counter_account_info.try_borrow_mut_lamports()?;
278 | const AMOUNT: u64 = 1;
279 | if **source_lamports < AMOUNT {
280 | msg!("source account has less than {} lamports", AMOUNT);
281 | let err = Err(anchor_lang::error::Error::from(ProgramError::InsufficientFunds));
282 | return err;
283 | }
284 | **source_lamports -= AMOUNT;
285 | let payer_account_info = ctx.accounts.payer.to_account_info();
286 | **payer_account_info.try_borrow_mut_lamports()? += AMOUNT;
287 | }
288 |
289 | Ok(())
290 | }
291 |
292 | // 186578 CU
293 | pub fn checked_math_test(_ctx: Context) -> Result<()> {
294 | let mut test_value_mul: u64 = 7;
295 | let mut test_value_shift: u64 = 7;
296 |
297 | // The compiler is very good at optimizing and inlining thats
298 | // why these calculations and in functions with parameters and the
299 | // No inlining flag.
300 |
301 | // Testing checked_mul 97314 CU
302 | compute_fn! { "checked mul" =>
303 | test_value_mul = test_checked_mul(test_value_mul, 7, 200, 60);
304 | }
305 |
306 | msg!("Test value mul: {}", test_value_mul);
307 |
308 | // Testing bit_shift 85113 CU
309 | compute_fn! { "bit shift" =>
310 | test_value_shift = check_bit_shift(test_value_shift, 7, 200, 60);
311 | }
312 |
313 | msg!("Test value shift: {}", test_value_shift);
314 |
315 | Ok(())
316 | }
317 |
318 | // Total 101237 CU
319 | pub fn clone_variables(_ctx: Context) -> Result<()> {
320 | let balances = vec![10_u64; 100]; // a vector with 10,000 elements
321 |
322 | let mut sum_reference = 0;
323 |
324 | // Here we can see that passing by reference is cheaper than cloning
325 | // Interesting is also that due to the bump allocator that solana
326 | // uses we will run out of memory as soon as we go to 40 iterations
327 | // on the loop that clones the vector. This is because the bump allocator
328 | // does not free memory and we only have 32 KB of heap space.
329 |
330 | // 47683 CU
331 | compute_fn! { "pass by reference" =>
332 | for _ in 0..39 {
333 | sum_reference += sum_vector_by_reference(&balances);
334 | }
335 | }
336 |
337 | msg!("Sum by reference: {}", sum_reference);
338 |
339 | let mut sum_clone = 0;
340 |
341 | // 49322 CU
342 | compute_fn! { "clone" =>
343 | for _ in 0..39 {
344 | sum_clone += sum_vector_by_value(balances.clone());
345 | }
346 | }
347 |
348 | msg!("Sum by clone: {}", sum_clone);
349 |
350 | Ok(())
351 | }
352 | }
353 |
354 | // Function that takes a reference to a vector
355 | fn sum_vector_by_reference(balances: &Vec) -> u64 {
356 | balances.iter().sum()
357 | }
358 |
359 | // Function that takes a vector by value
360 | fn sum_vector_by_value(balances: Vec) -> u64 {
361 | balances.iter().sum()
362 | }
363 |
364 | pub fn increase_counter_function(mut count: u64) -> u64 {
365 | count += 1;
366 | count
367 | }
368 |
369 | #[inline(never)]
370 | pub fn check_bit_shift(
371 | mut count: u64,
372 | mut extraValue: u64,
373 | first_loop: u64,
374 | second_loop: u64
375 | ) -> u64 {
376 | for i in 0..first_loop {
377 | count = i;
378 | for _ in 0..second_loop {
379 | count = bit_shift(count);
380 | }
381 | }
382 | count
383 | }
384 |
385 | #[inline(never)]
386 | pub fn bit_shift(mut count: u64) -> u64 {
387 | count << 1
388 | }
389 |
390 | #[inline(never)]
391 | pub fn test_checked_mul(
392 | mut count: u64,
393 | mut extraValue: u64,
394 | first_loop: u64,
395 | second_loop: u64
396 | ) -> u64 {
397 | for i in 0..first_loop {
398 | count = i;
399 | for _ in 0..second_loop {
400 | checked_mul(count);
401 | }
402 | }
403 | count
404 | }
405 |
406 | #[inline(never)]
407 | pub fn checked_mul(mut count: u64) -> u64 {
408 | count.checked_mul(2).expect("overflow")
409 | }
410 |
411 | #[derive(Accounts)]
412 | pub struct InitializeCounter<'info> {
413 | #[account(mut)]
414 | pub payer: Signer<'info>,
415 |
416 | #[account(init, space = 8 + CounterData::INIT_SPACE, payer = payer)]
417 | pub counter: Box>,
418 | pub system_program: Program<'info, System>,
419 | }
420 |
421 | #[derive(Accounts)]
422 | pub struct InitializeCounterZeroCopy<'info> {
423 | #[account(mut)]
424 | pub payer: Signer<'info>,
425 | #[account(init, space = 8 + CounterZeroCopy::INIT_SPACE, payer = payer)]
426 | pub counter_zero_copy: AccountLoader<'info, CounterZeroCopy>,
427 | pub system_program: Program<'info, System>,
428 | }
429 |
430 | // 15166 CU with signer 14863 CU without signer check
431 | #[derive(Accounts)]
432 | pub struct Update<'info> {
433 | #[account(mut)]
434 | pub counter: Account<'info, CounterData>,
435 | }
436 |
437 | /*
438 | When boxing the account the CU increase to 3,657 which indicated that it takes more cu to
439 | Calculate the data on the heap
440 | #[derive(Accounts)]
441 | pub struct Update<'info> {
442 | #[account(mut)]
443 | pub counter: Box>,
444 | }*/
445 |
446 | #[derive(Accounts)]
447 | pub struct InitPdaWithSeeds<'info> {
448 | #[account(init, seeds = [b"counter"], bump, payer = signer, space = 8 + CounterData::INIT_SPACE)]
449 | pub counter_checked: Account<'info, CounterData>,
450 | #[account(mut)]
451 | pub signer: Signer<'info>,
452 | pub system_program: Program<'info, System>,
453 | }
454 |
455 | #[derive(Accounts)]
456 | pub struct PdaAccounts<'info> {
457 | #[account(mut)]
458 | pub counter: Account<'info, CounterData>,
459 | // 12,136 CUs when not defining the bump, but only 1600 if using the bump that is saved in the counter_checked account
460 | #[account(seeds = [b"counter"], bump = counter_checked.bump)]
461 | pub counter_checked: Account<'info, CounterData>,
462 | }
463 |
464 | #[derive(Accounts)]
465 | pub struct DoCpi<'info> {
466 | #[account(mut)]
467 | pub payer: Signer<'info>,
468 | #[account(mut)]
469 | pub counter: Account<'info, CounterData>,
470 | pub system_program: Program<'info, System>,
471 | }
472 |
473 | #[derive(Accounts)]
474 | pub struct UpdateZeroCopy<'info> {
475 | #[account(mut)]
476 | pub counter_zero_copy: AccountLoader<'info, CounterZeroCopy>,
477 | }
478 |
479 | // 6389 CU
480 | #[account]
481 | #[derive(InitSpace)]
482 | pub struct CounterData {
483 | count: u64,
484 | test: Pubkey,
485 | test1: u64,
486 | test2: u64,
487 | //big_struct: BigStructNoZeroCopy, // When adding this big struct you will get a stack frame violation
488 | bump: u8,
489 | }
490 |
491 | // 5020 CU
492 | #[account(zero_copy)]
493 | #[repr(C)]
494 | #[derive(InitSpace)]
495 | pub struct CounterZeroCopy {
496 | count: u64,
497 | test: Pubkey,
498 | test1: u64,
499 | test2: u64,
500 | big_struct: BigStruct,
501 | }
502 |
503 | #[repr(C)]
504 | #[derive(AnchorSerialize, AnchorDeserialize, Copy, Clone, PartialEq, Eq, Zeroable, Pod, InitSpace)]
505 | pub struct BigStruct {
506 | test: Pubkey,
507 | test1: u64,
508 | test2: u64,
509 | test3: Pubkey,
510 | test4: u64,
511 | test5: u64,
512 | test6: Pubkey,
513 | pubkey_array: [Pubkey; 43],
514 | }
515 |
516 | #[account]
517 | #[derive(InitSpace)]
518 | pub struct BigStructNoZeroCopy {
519 | test: Pubkey,
520 | test1: u64,
521 | test2: u64,
522 | test3: Pubkey,
523 | test4: u64,
524 | test5: u64,
525 | test6: Pubkey,
526 | pubkey_array: [Pubkey; 120],
527 | }
528 |
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | # Optimizing CU in programs
2 |
3 | ## Introduction
4 |
5 | The get started there is a [video guide](https://www.youtube.com/watch?v=7CbAK7Oq_o4) on how to optimize CU in programs which covers the contents in this repository.
6 | And also a [Part1](https://www.youtube.com/watch?v=xoJ-3NkYXfY&ab_channel=Solandy%5Bsolandy.sol%5D) and [Part2](https://www.youtube.com/watch?v=Pwly1cOa2hg&ab_channel=Solandy%5Bsolandy.sol%5D) on how optimize programs by SolAndy.
7 |
8 | Every block on Solana has a blockspace limit of 48 million CUs and a 12 million CUs per account write lock. If you exhaust the CU limit your transaction will fail. Optimizing your program CUs has many advantages.
9 |
10 | Currently every transactions on Solana costs 5000 lamports per signature independant on the compute units used.
11 | Four reasons on why to optimize CU anyway:
12 |
13 | 1. A smaller transaction is more likely to be included in a block.
14 | 2. Currently every transaction costs 5000 lamports/sig no matter the CU. This may change in the future. Better be prepared.
15 | 3. It makes your program more composable, because when another program does a CPI in your program it also need to cover your CU.
16 | 4. More block space for every one. One block could theoretically hold around tens of thousands of simple transfer transactions for example. So the less intensive each transaction is the more we can get in a block.
17 |
18 | By default every transaction on solana requests 200.000 CUs.
19 | With the call setComputeLimit this can be increased to a maximum of 1.4 million.
20 |
21 | If you are only doing a simple transfer, you can set the CU limit to 300 for example.
22 |
23 | ```js
24 | const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
25 | units: 300,
26 | });
27 | ```
28 |
29 | There can also be priority fees which can be set like this:
30 |
31 | ```js
32 | const computePriceIx = ComputeBudgetProgram.setComputeUnitPrice({
33 | microLamports: 1,
34 | });
35 | ```
36 |
37 | This means for every requested CU, 1 microLamport is paid. This would result in a fee of 0.2 lamports.
38 | These instructions can be put into a transaction at any position.
39 |
40 | ```js
41 | const transaction = new Transaction().add(computePriceIx, computeLimitIx, ...);
42 | ```
43 |
44 | Find Compute Budget code here:
45 | https://github.com/solana-labs/solana/blob/090e11210aa7222d8295610a6ccac4acda711bb9/program-runtime/src/compute_budget.rs#L26-L87
46 |
47 | Blocks are packed using the real CU used and not the requested CU.
48 |
49 | There may be a CU cost to loaded account size as well soon with a maximum of 16.000 CU which would be charges heap space at rate of 8cu per 32K. (Max loaded accounts per transaction is 64Mb)
50 | https://github.com/solana-labs/solana/issues/29582
51 |
52 | ## How to measure CU
53 |
54 | The best way to measure CU is to use the solana program log.
55 |
56 | For that you can use this macro:
57 |
58 | ```rust
59 | /// Total extra compute units used per compute_fn! call 409 CU
60 | /// https://github.com/anza-xyz/agave/blob/d88050cda335f87e872eddbdf8506bc063f039d3/programs/bpf_loader/src/syscalls/logging.rs#L70
61 | /// https://github.com/anza-xyz/agave/blob/d88050cda335f87e872eddbdf8506bc063f039d3/program-runtime/src/compute_budget.rs#L150
62 | #[macro_export]
63 | macro_rules! compute_fn {
64 | ($msg:expr=> $($tt:tt)*) => {
65 | ::solana_program::msg!(concat!($msg, " {"));
66 | ::solana_program::log::sol_log_compute_units();
67 | let res = { $($tt)* };
68 | ::solana_program::log::sol_log_compute_units();
69 | ::solana_program::msg!(concat!(" } // ", $msg));
70 | res
71 | };
72 | }
73 | ```
74 |
75 | You put it in front and after the code block you want to measure like so:
76 |
77 | ```rust
78 |
79 | compute_fn!("My message" => {
80 | // Your code here
81 | });
82 |
83 | ```
84 |
85 | Then you can paste the logs into chatGPT and let i calculate the CU for you if you dont want to do it yourself.
86 | Here is the original from @thlorenz https://github.com/thlorenz/sol-contracts/blob/master/packages/sol-common/rust/src/lib.rs
87 |
88 | # Optimizations
89 |
90 | ## 1 Logging
91 |
92 | Logging is very expensive. Especially logging pubkeys and concatenating strings. Use pubkey.log instead if you need it and only log what is really necessary.
93 |
94 | ```rust
95 | // 11962 CU !!
96 | // Base58 encoding is expensive, concatenation is expensive
97 | compute_fn! { "Log a pubkey to account info" =>
98 | msg!("A string {0}", ctx.accounts.counter.to_account_info().key());
99 | }
100 |
101 | // 262 cu
102 | compute_fn! { "Log a pubkey" =>
103 | ctx.accounts.counter.to_account_info().key().log();
104 | }
105 |
106 | let pubkey = ctx.accounts.counter.to_account_info().key();
107 |
108 | // 206 CU
109 | compute_fn! { "Pubkey.log" =>
110 | pubkey.log();
111 | }
112 |
113 | // 357 CU - string concatenation is expensive
114 | compute_fn! { "Log a pubkey simple concat" =>
115 | msg!("A string {0}", "5w6z5PWvtkCd4PaAV7avxE6Fy5brhZsFdbRLMt8UefRQ");
116 | }
117 | ```
118 |
119 | ## 2 Data Types
120 |
121 | Bigger data types cost more CU. Use the smallest data type possible.
122 |
123 | ```rust
124 | // 357
125 | compute_fn! { "Push Vector u64 " =>
126 | let mut a: Vec = Vec::new();
127 | a.push(1);
128 | a.push(1);
129 | a.push(1);
130 | a.push(1);
131 | a.push(1);
132 | a.push(1);
133 | }
134 |
135 | // 211 CU
136 | compute_fn! { "Vector u8 " =>
137 | let mut a: Vec = Vec::new();
138 | a.push(1);
139 | a.push(1);
140 | a.push(1);
141 | a.push(1);
142 | a.push(1);
143 | a.push(1);
144 | }
145 |
146 | ```
147 |
148 | ## 3 Serialization
149 |
150 | Borsh serialization can be expensive depending on the account structs, use zero copy when possible and directly interact with the memory. It also saves more stack space than boxing. Operations on the stack are slightly more efficient though.
151 |
152 | ```rust
153 | // 6302 CU
154 | pub fn initialize(_ctx: Context) -> Result<()> {
155 | Ok(())
156 | }
157 |
158 | // 5020 CU
159 | pub fn initialize_zero_copy(_ctx: Context) -> Result<()> {
160 | Ok(())
161 | }
162 | ```
163 |
164 | ```rust
165 | // 108 CU - total CU including serialization 2600
166 | let counter = &mut ctx.accounts.counter;
167 | compute_fn! { "Borsh Serialize" =>
168 | counter.count = counter.count.checked_add(1).unwrap();
169 | }
170 |
171 | // 151 CU - total CU including serialization 1254
172 | let counter = &mut ctx.accounts.counter_zero_copy.load_mut()?;
173 | compute_fn! { "Zero Copy Serialize" =>
174 | counter.count = counter.count.checked_add(1).unwrap();
175 | }
176 | ```
177 |
178 | ## 4 PDAs
179 |
180 | Depending on the seeds find_program_address can use multiple loops and become very expensive. You can save the bump in an account or pass it in from the client to remove this overhead:
181 |
182 | ```rust
183 | pub fn pdas(ctx: Context) -> Result<()> {
184 | let program_id = Pubkey::from_str("5w6z5PWvtkCd4PaAV7avxE6Fy5brhZsFdbRLMt8UefRQ").unwrap();
185 |
186 | // 12,136 CUs
187 | compute_fn! { "Find PDA" =>
188 | Pubkey::find_program_address(&[b"counter"], ctx.program_id);
189 | }
190 |
191 | // 1,651 CUs
192 | compute_fn! { "Find PDA" =>
193 | Pubkey::create_program_address(&[b"counter", &[248_u8]], &program_id).unwrap();
194 | }
195 |
196 | Ok(())
197 | }
198 |
199 | #[derive(Accounts)]
200 | pub struct PdaAccounts<'info> {
201 | #[account(mut)]
202 | pub counter: Account<'info, CounterData>,
203 | // 12,136 CUs when not defining the bump
204 | #[account(
205 | seeds = [b"counter"],
206 | bump
207 | )]
208 | pub counter_checked: Account<'info, CounterData>,
209 | }
210 |
211 | #[derive(Accounts)]
212 | pub struct PdaAccounts<'info> {
213 | #[account(mut)]
214 | pub counter: Account<'info, CounterData>,
215 | // only 1600 if using the bump that is saved in the counter_checked account
216 | #[account(
217 | seeds = [b"counter"],
218 | bump = counter_checked.bump
219 | )]
220 | pub counter_checked: Account<'info, CounterData>,
221 | }
222 |
223 | ```
224 |
225 | ## 5 Closures and function
226 |
227 | During the tests it looks like that closures, function calls and inlining have a similar cost and were well optimized by the compiler.
228 |
229 | ## 6 CPIs
230 |
231 | Every CPI comes with a cost and you also need to calculate in the costs of the called programs function.
232 | If possible avoid doing many CPIs.
233 | I did not find a difference in CPI cost between anchor and native and the optimization is more in the called function.
234 | A CPI for a transfer with the system program costs 2215 CU.
235 | Interesting is though that error handling also costs a lot of CU. So profile how you handle errors and optimize there.
236 |
237 | ```rust
238 | // 2,215 CUs
239 | compute_fn! { "CPI system program" =>
240 | let cpi_context = CpiContext::new(
241 | ctx.accounts.system_program.to_account_info(),
242 | system_program::Transfer {
243 | from: ctx.accounts.payer.to_account_info().clone(),
244 | to: ctx.accounts.counter.to_account_info().clone(),
245 | },
246 | );
247 | system_program::transfer(cpi_context, 1)?;
248 | }
249 |
250 | // 251 CUs. In an error case though the whole transactions is 1,199 CUs bigger than without. So error handling is expensive
251 | compute_fn! { "Transfer borrowing lamports" =>
252 | let counter_account_info = ctx.accounts.counter.to_account_info();
253 | let mut source_lamports = counter_account_info.try_borrow_mut_lamports()?;
254 | const AMOUNT: u64 = 1;
255 | if **source_lamports < AMOUNT {
256 | msg!("source account has less than {} lamports", AMOUNT);
257 | let err = Err(anchor_lang::error::Error::from(ProgramError::InsufficientFunds));
258 | return err;
259 | }
260 | **source_lamports -= AMOUNT;
261 | let payer_account_info = ctx.accounts.payer.to_account_info();
262 | **payer_account_info.try_borrow_mut_lamports()? += AMOUNT;
263 | }
264 | ```
265 |
266 | ## 7 Checked Math
267 |
268 | It turns out that checked math is more expensive than unchecked math. This is because on every operation the program needs to check if the operation is valid and does not under- or overflow for example. If you are sure that the operation is valid you can use unchecked math so save some CU.
269 | Also the compiler is very good at optimizing the code and inline checks and remove unnecessary calculations if a value is not used for example.
270 | This is why the functions have the `no_inline` attribute to prevent the compiler from optimizing the code away and the calculations are in public functions and the result values are logged after the calculation.
271 |
272 | ```rust
273 | // Testing checked_mul 97314 CU
274 | compute_fn! { "checked mul" =>
275 | test_checked_mul(test_value_mul, 7, 200, 60);
276 | }
277 |
278 | msg!("Test value mul: {}", test_value_mul);
279 |
280 | // Testing bit_shift 85113 CU
281 | compute_fn! { "bit shift" =>
282 | check_bit_shift(test_value_shift, 7, 200, 60);
283 | }
284 | ```
285 |
286 | ## 8 Clone vs Reference
287 |
288 | Here we can see that passing by reference is cheaper than cloning.
289 | Interesting is also that due to the bump allocator that solana
290 | uses we will run out of memory as soon as we go to 40 iterations
291 | on the loop that clones the vector. This is because the bump allocator
292 | does not free memory and we only have 32 KB of heap space. By passing in the balances vector by reference we can avoid this problem.
293 |
294 | ```rust
295 | let balances = vec![10_u64; 100]; // a vector with 10,000 elements
296 |
297 | // 47683 CU
298 | compute_fn! { "Pass by reference" =>
299 | for _ in 0..39 {
300 | sum_reference += sum_vector_by_reference(&balances);
301 | }
302 | }
303 |
304 | msg!("Sum by reference: {}", sum_reference);
305 |
306 | let mut sum_clone = 0;
307 |
308 | // 49322 CU
309 | compute_fn! { "Clone" =>
310 | for _ in 0..39 {
311 | sum_clone += sum_vector_by_value(balances.clone());
312 | }
313 | }
314 |
315 | msg!("Sum by clone: {}", sum_clone);
316 | ```
317 |
318 | ## 9 Native vs Anchor vs Asm vs C vs unsave rust
319 |
320 | Anchor is a great tool for writing programs, but it comes with a cost. Every check that anchor does costs CU. While most checks are useful, there may be room for improvement. The anchor generated code is not necessarily optimized for CU.
321 |
322 | | Test Title | Anchor | Native | ASM \*1 | C |
323 | | ------------ | ---------------------------------------------------------- | ------------------------------------------ | ---------------------------------------------------- | ----------------------------------- |
324 | | Deploy size | 265677 bytes (1.8500028 sol) | 48573 bytes (0.33895896 sol) | 1389 bytes (0.01055832 sol) | 1333 Bytes (0.01016856 sol) |
325 | | Counter Inc | [946 CU](counterAnchor/anchor/programs/counter/src/lib.rs) | [843 CU](counterNative/program/src/lib.rs) | [4 CU](counterAsmSbpf/src/sbpfCounter/sbpfCounter.s) | [5 CU](counterC/counter/src/main.c) |
326 | | Signer Check | 303 CU | 103 CU | 1 CU | - |
327 |
328 | | Test Title | Unsave Rust \*2 |
329 | | ------------ | ----------------------------------- |
330 | | Deploy size | 973 bytes (0.00766296 sol) |
331 | | Counter Inc | [5 CU](counterC/counter/src/lib.rs) |
332 | | Signer Check | - |
333 |
334 | *1 Note though that the assembly example is a very simple example and does not include any checks or error handling.
335 | *2 Can be decreased to 4 CU using [sbf-asm-macros](https://crates.io/crates/sbpf-asm-macros) to remove the return type since it is not needed in success case.
336 |
337 | Size will increase with every check that you implement and every instruction that you add. You will also need to increase your program size whenever it becomes bigger.
338 |
339 | Note please that all these tests are tests are super specific for a counter and not really realistic for a production program. Theses tests are only to show the differences between the different program types and ways to think about optimizing your program.
340 |
341 | ## 10 Writing programs in Assembly
342 |
343 | To get started you can watch this [video guide](https://www.youtube.com/watch?v=eacDC0VgyxI&t=1273s&ab_channel=SolPlay) on how to write programs in assembly.
344 |
345 | Writing programs in assembly can be very efficient. You can write very small programs that use very little CU. This can be great for example to write primitives that are used in other programs like checking token balances at the end of a swap or similar.
346 |
347 | The downside is that you need to write everything yourself and you need to be very careful with the stack and heap. You also need to be very careful with the memory layout and the program will be harder to read and maintain. Also Anchor and even native rust are way easier to write secure programs with! Only use this if you know what you are doing.
348 |
349 | There are two counter example in this repository. One was written using the [solana-program-rosetta](https://github.com/joncinque/solana-program-rosetta?tab=readme-ov-file#assembly) by Jon Cinque. It is a great tool to get started with writing programs in assembly. It comes complete with bankrun tests written in rust. It also contains examples written in Zig and C which can also bring great performance improvements.
350 |
351 | Instead of solana-program-rosetta you can also use [SBPF](https://github.com/deanmlittle/sbpf) by [Dean](https://github.com/deanmlittle) which gives your very convenient functions like `sbpf init`, `sbpf build` and `sbpf deploy`. This one comes with Js tests using `mocha` and `chai` and is also a great tool to get started with writing programs in assembly and makes setting up projects much easier.
352 |
353 | If you want to get started on Solana ASM program writing you should start by reading the [docs on the exact memory layout](https://solana.com/docs/programs/faq#input-parameter-serialization) of the [entry point](https://github.com/anza-xyz/agave/blob/1b3eb3df5e244cdbdedb7eff8978823ef0611669/sdk/program/src/entrypoint.rs#L336) and the registers for heap and stack frame.
354 |
355 | Great [repository links and tips for ASM programs](https://github.com/deanmlittle/awesome-sbpf).
356 |
357 | There is also a VSCode extension by Dean: https://github.com/deanmlittle/vscode-sbpf-asm that helps with autocomplete and syntax highlighting.
358 |
359 | It is probably not realistic to write huge programs in assembly, but for small programs or primitives it can be a useful tool. Also knowing how Rust and C code transforms to assembly code can be useful when optimizing your programs.
360 |
361 | Here are some ASM examples for reference:
362 |
363 | - [Fibonacci example](https://github.com/deanmlittle/solana-fibonacci-asm)
364 | - [Sol Transfer](https://github.com/joncinque/solana-program-rosetta/tree/main/transfer-lamports/asm)
365 | - Hello world: https://github.com/deanmlittle/ezbpf run `sbpf init`
366 | - The Counter examples can be found here in this repo
367 |
368 | If you want to use AI like chat GPT to write your programs make sure to train it on these examples before you start.
369 |
370 | ## 11 Other low level optimizations
371 |
372 | ### Compiler flags
373 |
374 | There is certain compiler flags that you set set to decrease CU usage of yor program. You can set the following flags in your `Cargo.toml`. For example you could disable overflow checks.
375 | Note thought that changing a flag like overflow checks of course comes with additional risks like overflow bugs.
376 |
377 | TODO: Add performance tests on different flags.
378 | https://doc.rust-lang.org/cargo/reference/profiles.html#overflow-checks
379 |
380 | ### Inline
381 |
382 | Inlining functions can save CU. The compiler is very good at optimizing the code and inline checks and remove unnecessary calculations if a value is not used for example.
383 |
384 | ```rust
385 | #[inline(always)]
386 | fn add(a: u64, b: u64) -> u64 {
387 | a + b
388 | }
389 | ```
390 |
391 | Note though that you need to balance inline always vs inline never. Inlining saves CU but needs more stack space while inline never saves stack space but costs more CU.
392 |
393 | ### Non standart heap allocators
394 |
395 | The standard heap allocator is a bump heap allocator which does not free memory. This can lead to out of memory errors if you use a lot of memory. You can use a different heap allocator.
396 |
397 | Metaplex token meta data program uses smalloc heap for example: https://github.com/metaplex-foundation/mpl-core-candy-machine/pull/10
398 |
399 | ### Different entry points
400 |
401 | The standard entry points is not necessarily the most efficient one. You can use a different entry point to save CU. For example the no_std entry point:
402 | https://github.com/cavemanloverboy/solana-nostd-entrypoint
403 | It uses unsafe rust though.
404 | You can read on some comparison of different entry points here: https://github.com/hetdagli234/optimising-solana-programs/tree/main
405 | and here: https://github.com/febo/eisodos
406 |
407 | ## 12 Analyze and optimize yourself
408 |
409 | Most important here is actually to know that every check and every serialization costs compute and how to profile and optimize it yourself since every program is different. Profile and optimize your programs today!
410 |
411 | Feel free to play around with it and add more examples. Also here is a very nice article from @RareSkills_io https://www.rareskills.io/post/solana-compute-unit-price on that topic. I replicated some of the examples :)
412 |
413 | Also here is a nice Twitter thread on the topic: https://x.com/daglihet/status/1840396773833261085 with another CU optimization repository looking also at different entry points and how to optimize them. https://github.com/hetdagli234/optimising-solana-programs/tree/main
414 |
415 | Some nice optimizations can also he found in this [twitter post by dev4all](https://twitter.com/kAsky53/status/1777799557759254810).
416 |
--------------------------------------------------------------------------------
/counterAnchor/anchor/yarn.lock:
--------------------------------------------------------------------------------
1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
2 | # yarn lockfile v1
3 |
4 |
5 | "@babel/runtime@^7.24.7":
6 | version "7.24.7"
7 | resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.24.7.tgz#f4f0d5530e8dbdf59b3451b9b3e594b6ba082e12"
8 | integrity sha512-UwgBRMjJP+xv857DCngvqXI3Iq6J4v0wXmwc6sapg+zyhbwmQX67LUEFrkK5tbyJ30jGuG3ZvWpBiB9LCy1kWw==
9 | dependencies:
10 | regenerator-runtime "^0.14.0"
11 |
12 | "@babel/runtime@^7.25.0":
13 | version "7.25.7"
14 | resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.25.7.tgz#7ffb53c37a8f247c8c4d335e89cdf16a2e0d0fb6"
15 | integrity sha512-FjoyLe754PMiYsFaN5C94ttGiOmBNYTf6pLr4xXHAT5uctHb092PBszndLDR5XA/jghQvn4n7JMHl7dmTgbm9w==
16 | dependencies:
17 | regenerator-runtime "^0.14.0"
18 |
19 | "@coral-xyz/anchor-errors@^0.30.1":
20 | version "0.30.1"
21 | resolved "https://registry.yarnpkg.com/@coral-xyz/anchor-errors/-/anchor-errors-0.30.1.tgz#bdfd3a353131345244546876eb4afc0e125bec30"
22 | integrity sha512-9Mkradf5yS5xiLWrl9WrpjqOrAV+/W2RQHDlbnAZBivoGpOs1ECjoDCkVk4aRG8ZdiFiB8zQEVlxf+8fKkmSfQ==
23 |
24 | "@coral-xyz/anchor@^0.30.1":
25 | version "0.30.1"
26 | resolved "https://registry.yarnpkg.com/@coral-xyz/anchor/-/anchor-0.30.1.tgz#17f3e9134c28cd0ea83574c6bab4e410bcecec5d"
27 | integrity sha512-gDXFoF5oHgpriXAaLpxyWBHdCs8Awgf/gLHIo6crv7Aqm937CNdY+x+6hoj7QR5vaJV7MxWSQ0NGFzL3kPbWEQ==
28 | dependencies:
29 | "@coral-xyz/anchor-errors" "^0.30.1"
30 | "@coral-xyz/borsh" "^0.30.1"
31 | "@noble/hashes" "^1.3.1"
32 | "@solana/web3.js" "^1.68.0"
33 | bn.js "^5.1.2"
34 | bs58 "^4.0.1"
35 | buffer-layout "^1.2.2"
36 | camelcase "^6.3.0"
37 | cross-fetch "^3.1.5"
38 | crypto-hash "^1.3.0"
39 | eventemitter3 "^4.0.7"
40 | pako "^2.0.3"
41 | snake-case "^3.0.4"
42 | superstruct "^0.15.4"
43 | toml "^3.0.0"
44 |
45 | "@coral-xyz/borsh@^0.30.1":
46 | version "0.30.1"
47 | resolved "https://registry.yarnpkg.com/@coral-xyz/borsh/-/borsh-0.30.1.tgz#869d8833abe65685c72e9199b8688477a4f6b0e3"
48 | integrity sha512-aaxswpPrCFKl8vZTbxLssA2RvwX2zmKLlRCIktJOwW+VpVwYtXRtlWiIP+c2pPRKneiTiWCN2GEMSH9j1zTlWQ==
49 | dependencies:
50 | bn.js "^5.1.2"
51 | buffer-layout "^1.2.0"
52 |
53 | "@noble/curves@^1.4.0":
54 | version "1.4.0"
55 | resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-1.4.0.tgz#f05771ef64da724997f69ee1261b2417a49522d6"
56 | integrity sha512-p+4cb332SFCrReJkCYe8Xzm0OWi4Jji5jVdIZRL/PmacmDkFNw6MrrV+gGpiPxLHbV+zKFRywUWbaseT+tZRXg==
57 | dependencies:
58 | "@noble/hashes" "1.4.0"
59 |
60 | "@noble/curves@^1.4.2":
61 | version "1.6.0"
62 | resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-1.6.0.tgz#be5296ebcd5a1730fccea4786d420f87abfeb40b"
63 | integrity sha512-TlaHRXDehJuRNR9TfZDNQ45mMEd5dwUwmicsafcIX4SsNiqnCHKjE/1alYPd/lDRVhxdhUAlv8uEhMCI5zjIJQ==
64 | dependencies:
65 | "@noble/hashes" "1.5.0"
66 |
67 | "@noble/hashes@1.4.0", "@noble/hashes@^1.3.1", "@noble/hashes@^1.4.0":
68 | version "1.4.0"
69 | resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.4.0.tgz#45814aa329f30e4fe0ba49426f49dfccdd066426"
70 | integrity sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==
71 |
72 | "@noble/hashes@1.5.0":
73 | version "1.5.0"
74 | resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.5.0.tgz#abadc5ca20332db2b1b2aa3e496e9af1213570b0"
75 | integrity sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==
76 |
77 | "@solana/buffer-layout@^4.0.1":
78 | version "4.0.1"
79 | resolved "https://registry.yarnpkg.com/@solana/buffer-layout/-/buffer-layout-4.0.1.tgz#b996235eaec15b1e0b5092a8ed6028df77fa6c15"
80 | integrity sha512-E1ImOIAD1tBZFRdjeM4/pzTiTApC0AOBGwyAMS4fwIodCWArzJ3DWdoh8cKxeFM2fElkxBh2Aqts1BPC373rHA==
81 | dependencies:
82 | buffer "~6.0.3"
83 |
84 | "@solana/web3.js@1.95.3":
85 | version "1.95.3"
86 | resolved "https://registry.yarnpkg.com/@solana/web3.js/-/web3.js-1.95.3.tgz#70b5f4d76823f56b5af6403da51125fffeb65ff3"
87 | integrity sha512-O6rPUN0w2fkNqx/Z3QJMB9L225Ex10PRDH8bTaIUPZXMPV0QP8ZpPvjQnXK+upUczlRgzHzd6SjKIha1p+I6og==
88 | dependencies:
89 | "@babel/runtime" "^7.25.0"
90 | "@noble/curves" "^1.4.2"
91 | "@noble/hashes" "^1.4.0"
92 | "@solana/buffer-layout" "^4.0.1"
93 | agentkeepalive "^4.5.0"
94 | bigint-buffer "^1.1.5"
95 | bn.js "^5.2.1"
96 | borsh "^0.7.0"
97 | bs58 "^4.0.1"
98 | buffer "6.0.3"
99 | fast-stable-stringify "^1.0.0"
100 | jayson "^4.1.1"
101 | node-fetch "^2.7.0"
102 | rpc-websockets "^9.0.2"
103 | superstruct "^2.0.2"
104 |
105 | "@solana/web3.js@^1.68.0":
106 | version "1.93.4"
107 | resolved "https://registry.yarnpkg.com/@solana/web3.js/-/web3.js-1.93.4.tgz#f16c9f8584e3bd518186e95c4a6347e269dede4f"
108 | integrity sha512-6hHtSYmkUPwcm3eGeqBanMT3pDAhTprrm2IUoboSjNN4gKCBEkY9uIeS2TZKLpsGY+R6fDub5pRi+e4xFVv55w==
109 | dependencies:
110 | "@babel/runtime" "^7.24.7"
111 | "@noble/curves" "^1.4.0"
112 | "@noble/hashes" "^1.4.0"
113 | "@solana/buffer-layout" "^4.0.1"
114 | agentkeepalive "^4.5.0"
115 | bigint-buffer "^1.1.5"
116 | bn.js "^5.2.1"
117 | borsh "^0.7.0"
118 | bs58 "^4.0.1"
119 | buffer "6.0.3"
120 | fast-stable-stringify "^1.0.0"
121 | jayson "^4.1.0"
122 | node-fetch "^2.7.0"
123 | rpc-websockets "^9.0.2"
124 | superstruct "^1.0.4"
125 |
126 | "@swc/helpers@^0.5.11":
127 | version "0.5.11"
128 | resolved "https://registry.yarnpkg.com/@swc/helpers/-/helpers-0.5.11.tgz#5bab8c660a6e23c13b2d23fcd1ee44a2db1b0cb7"
129 | integrity sha512-YNlnKRWF2sVojTpIyzwou9XoTNbzbzONwRhOoniEioF1AtaitTvVZblaQRrAzChWQ1bLYyYSWzM18y4WwgzJ+A==
130 | dependencies:
131 | tslib "^2.4.0"
132 |
133 | "@types/connect@^3.4.33":
134 | version "3.4.38"
135 | resolved "https://registry.yarnpkg.com/@types/connect/-/connect-3.4.38.tgz#5ba7f3bc4fbbdeaff8dded952e5ff2cc53f8d858"
136 | integrity sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==
137 | dependencies:
138 | "@types/node" "*"
139 |
140 | "@types/node@*":
141 | version "20.14.9"
142 | resolved "https://registry.yarnpkg.com/@types/node/-/node-20.14.9.tgz#12e8e765ab27f8c421a1820c99f5f313a933b420"
143 | integrity sha512-06OCtnTXtWOZBJlRApleWndH4JsRVs1pDCc8dLSQp+7PpUpX3ePdHyeNSFTeSe7FtKyQkrlPvHwJOW3SLd8Oyg==
144 | dependencies:
145 | undici-types "~5.26.4"
146 |
147 | "@types/node@^12.12.54":
148 | version "12.20.55"
149 | resolved "https://registry.yarnpkg.com/@types/node/-/node-12.20.55.tgz#c329cbd434c42164f846b909bd6f85b5537f6240"
150 | integrity sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==
151 |
152 | "@types/uuid@^8.3.4":
153 | version "8.3.4"
154 | resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-8.3.4.tgz#bd86a43617df0594787d38b735f55c805becf1bc"
155 | integrity sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==
156 |
157 | "@types/ws@^7.4.4":
158 | version "7.4.7"
159 | resolved "https://registry.yarnpkg.com/@types/ws/-/ws-7.4.7.tgz#f7c390a36f7a0679aa69de2d501319f4f8d9b702"
160 | integrity sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==
161 | dependencies:
162 | "@types/node" "*"
163 |
164 | "@types/ws@^8.2.2":
165 | version "8.5.10"
166 | resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.10.tgz#4acfb517970853fa6574a3a6886791d04a396787"
167 | integrity sha512-vmQSUcfalpIq0R9q7uTo2lXs6eGIpt9wtnLdMv9LVpIjCA/+ufZRozlVoVelIYixx1ugCBKDhn89vnsEGOCx9A==
168 | dependencies:
169 | "@types/node" "*"
170 |
171 | JSONStream@^1.3.5:
172 | version "1.3.5"
173 | resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
174 | integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
175 | dependencies:
176 | jsonparse "^1.2.0"
177 | through ">=2.2.7 <3"
178 |
179 | agentkeepalive@^4.5.0:
180 | version "4.5.0"
181 | resolved "https://registry.yarnpkg.com/agentkeepalive/-/agentkeepalive-4.5.0.tgz#2673ad1389b3c418c5a20c5d7364f93ca04be923"
182 | integrity sha512-5GG/5IbQQpC9FpkRGsSvZI5QYeSCzlJHdpBQntCsuTOxhKD8lqKhrleg2Yi7yvMIf82Ycmmqln9U8V9qwEiJew==
183 | dependencies:
184 | humanize-ms "^1.2.1"
185 |
186 | base-x@^3.0.2:
187 | version "3.0.9"
188 | resolved "https://registry.yarnpkg.com/base-x/-/base-x-3.0.9.tgz#6349aaabb58526332de9f60995e548a53fe21320"
189 | integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==
190 | dependencies:
191 | safe-buffer "^5.0.1"
192 |
193 | base64-js@^1.3.1:
194 | version "1.5.1"
195 | resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
196 | integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
197 |
198 | bigint-buffer@^1.1.5:
199 | version "1.1.5"
200 | resolved "https://registry.yarnpkg.com/bigint-buffer/-/bigint-buffer-1.1.5.tgz#d038f31c8e4534c1f8d0015209bf34b4fa6dd442"
201 | integrity sha512-trfYco6AoZ+rKhKnxA0hgX0HAbVP/s808/EuDSe2JDzUnCp/xAsli35Orvk67UrTEcwuxZqYZDmfA2RXJgxVvA==
202 | dependencies:
203 | bindings "^1.3.0"
204 |
205 | bindings@^1.3.0:
206 | version "1.5.0"
207 | resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
208 | integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
209 | dependencies:
210 | file-uri-to-path "1.0.0"
211 |
212 | bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1:
213 | version "5.2.1"
214 | resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.1.tgz#0bc527a6a0d18d0aa8d5b0538ce4a77dccfa7b70"
215 | integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==
216 |
217 | borsh@^0.7.0:
218 | version "0.7.0"
219 | resolved "https://registry.yarnpkg.com/borsh/-/borsh-0.7.0.tgz#6e9560d719d86d90dc589bca60ffc8a6c51fec2a"
220 | integrity sha512-CLCsZGIBCFnPtkNnieW/a8wmreDmfUtjU2m9yHrzPXIlNbqVs0AQrSatSG6vdNYUqdc83tkQi2eHfF98ubzQLA==
221 | dependencies:
222 | bn.js "^5.2.0"
223 | bs58 "^4.0.0"
224 | text-encoding-utf-8 "^1.0.2"
225 |
226 | bs58@^4.0.0, bs58@^4.0.1:
227 | version "4.0.1"
228 | resolved "https://registry.yarnpkg.com/bs58/-/bs58-4.0.1.tgz#be161e76c354f6f788ae4071f63f34e8c4f0a42a"
229 | integrity sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==
230 | dependencies:
231 | base-x "^3.0.2"
232 |
233 | buffer-layout@^1.2.0, buffer-layout@^1.2.2:
234 | version "1.2.2"
235 | resolved "https://registry.yarnpkg.com/buffer-layout/-/buffer-layout-1.2.2.tgz#b9814e7c7235783085f9ca4966a0cfff112259d5"
236 | integrity sha512-kWSuLN694+KTk8SrYvCqwP2WcgQjoRCiF5b4QDvkkz8EmgD+aWAIceGFKMIAdmF/pH+vpgNV3d3kAKorcdAmWA==
237 |
238 | buffer@6.0.3, buffer@^6.0.3, buffer@~6.0.3:
239 | version "6.0.3"
240 | resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6"
241 | integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==
242 | dependencies:
243 | base64-js "^1.3.1"
244 | ieee754 "^1.2.1"
245 |
246 | bufferutil@^4.0.1:
247 | version "4.0.8"
248 | resolved "https://registry.yarnpkg.com/bufferutil/-/bufferutil-4.0.8.tgz#1de6a71092d65d7766c4d8a522b261a6e787e8ea"
249 | integrity sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==
250 | dependencies:
251 | node-gyp-build "^4.3.0"
252 |
253 | camelcase@^6.3.0:
254 | version "6.3.0"
255 | resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
256 | integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
257 |
258 | commander@^2.20.3:
259 | version "2.20.3"
260 | resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
261 | integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
262 |
263 | cross-fetch@^3.1.5:
264 | version "3.1.8"
265 | resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.8.tgz#0327eba65fd68a7d119f8fb2bf9334a1a7956f82"
266 | integrity sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==
267 | dependencies:
268 | node-fetch "^2.6.12"
269 |
270 | crypto-hash@^1.3.0:
271 | version "1.3.0"
272 | resolved "https://registry.yarnpkg.com/crypto-hash/-/crypto-hash-1.3.0.tgz#b402cb08f4529e9f4f09346c3e275942f845e247"
273 | integrity sha512-lyAZ0EMyjDkVvz8WOeVnuCPvKVBXcMv1l5SVqO1yC7PzTwrD/pPje/BIRbWhMoPe436U+Y2nD7f5bFx0kt+Sbg==
274 |
275 | delay@^5.0.0:
276 | version "5.0.0"
277 | resolved "https://registry.yarnpkg.com/delay/-/delay-5.0.0.tgz#137045ef1b96e5071060dd5be60bf9334436bd1d"
278 | integrity sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw==
279 |
280 | dot-case@^3.0.4:
281 | version "3.0.4"
282 | resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
283 | integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
284 | dependencies:
285 | no-case "^3.0.4"
286 | tslib "^2.0.3"
287 |
288 | es6-promise@^4.0.3:
289 | version "4.2.8"
290 | resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
291 | integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
292 |
293 | es6-promisify@^5.0.0:
294 | version "5.0.0"
295 | resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
296 | integrity sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ==
297 | dependencies:
298 | es6-promise "^4.0.3"
299 |
300 | eventemitter3@^4.0.7:
301 | version "4.0.7"
302 | resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
303 | integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
304 |
305 | eventemitter3@^5.0.1:
306 | version "5.0.1"
307 | resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-5.0.1.tgz#53f5ffd0a492ac800721bb42c66b841de96423c4"
308 | integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==
309 |
310 | eyes@^0.1.8:
311 | version "0.1.8"
312 | resolved "https://registry.yarnpkg.com/eyes/-/eyes-0.1.8.tgz#62cf120234c683785d902348a800ef3e0cc20bc0"
313 | integrity sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ==
314 |
315 | fast-stable-stringify@^1.0.0:
316 | version "1.0.0"
317 | resolved "https://registry.yarnpkg.com/fast-stable-stringify/-/fast-stable-stringify-1.0.0.tgz#5c5543462b22aeeefd36d05b34e51c78cb86d313"
318 | integrity sha512-wpYMUmFu5f00Sm0cj2pfivpmawLZ0NKdviQ4w9zJeR8JVtOpOxHmLaJuj0vxvGqMJQWyP/COUkF75/57OKyRag==
319 |
320 | file-uri-to-path@1.0.0:
321 | version "1.0.0"
322 | resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
323 | integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
324 |
325 | humanize-ms@^1.2.1:
326 | version "1.2.1"
327 | resolved "https://registry.yarnpkg.com/humanize-ms/-/humanize-ms-1.2.1.tgz#c46e3159a293f6b896da29316d8b6fe8bb79bbed"
328 | integrity sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==
329 | dependencies:
330 | ms "^2.0.0"
331 |
332 | ieee754@^1.2.1:
333 | version "1.2.1"
334 | resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
335 | integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
336 |
337 | isomorphic-ws@^4.0.1:
338 | version "4.0.1"
339 | resolved "https://registry.yarnpkg.com/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz#55fd4cd6c5e6491e76dc125938dd863f5cd4f2dc"
340 | integrity sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w==
341 |
342 | jayson@^4.1.0:
343 | version "4.1.0"
344 | resolved "https://registry.yarnpkg.com/jayson/-/jayson-4.1.0.tgz#60dc946a85197317f2b1439d672a8b0a99cea2f9"
345 | integrity sha512-R6JlbyLN53Mjku329XoRT2zJAE6ZgOQ8f91ucYdMCD4nkGCF9kZSrcGXpHIU4jeKj58zUZke2p+cdQchU7Ly7A==
346 | dependencies:
347 | "@types/connect" "^3.4.33"
348 | "@types/node" "^12.12.54"
349 | "@types/ws" "^7.4.4"
350 | JSONStream "^1.3.5"
351 | commander "^2.20.3"
352 | delay "^5.0.0"
353 | es6-promisify "^5.0.0"
354 | eyes "^0.1.8"
355 | isomorphic-ws "^4.0.1"
356 | json-stringify-safe "^5.0.1"
357 | uuid "^8.3.2"
358 | ws "^7.4.5"
359 |
360 | jayson@^4.1.1:
361 | version "4.1.2"
362 | resolved "https://registry.yarnpkg.com/jayson/-/jayson-4.1.2.tgz#443c26a8658703e0b2e881117b09395d88b6982e"
363 | integrity sha512-5nzMWDHy6f+koZOuYsArh2AXs73NfWYVlFyJJuCedr93GpY+Ku8qq10ropSXVfHK+H0T6paA88ww+/dV+1fBNA==
364 | dependencies:
365 | "@types/connect" "^3.4.33"
366 | "@types/node" "^12.12.54"
367 | "@types/ws" "^7.4.4"
368 | JSONStream "^1.3.5"
369 | commander "^2.20.3"
370 | delay "^5.0.0"
371 | es6-promisify "^5.0.0"
372 | eyes "^0.1.8"
373 | isomorphic-ws "^4.0.1"
374 | json-stringify-safe "^5.0.1"
375 | uuid "^8.3.2"
376 | ws "^7.5.10"
377 |
378 | json-stringify-safe@^5.0.1:
379 | version "5.0.1"
380 | resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
381 | integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
382 |
383 | jsonparse@^1.2.0:
384 | version "1.3.1"
385 | resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
386 | integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
387 |
388 | lower-case@^2.0.2:
389 | version "2.0.2"
390 | resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
391 | integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
392 | dependencies:
393 | tslib "^2.0.3"
394 |
395 | ms@^2.0.0:
396 | version "2.1.3"
397 | resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
398 | integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
399 |
400 | no-case@^3.0.4:
401 | version "3.0.4"
402 | resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
403 | integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
404 | dependencies:
405 | lower-case "^2.0.2"
406 | tslib "^2.0.3"
407 |
408 | node-fetch@^2.6.12, node-fetch@^2.7.0:
409 | version "2.7.0"
410 | resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d"
411 | integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==
412 | dependencies:
413 | whatwg-url "^5.0.0"
414 |
415 | node-gyp-build@^4.3.0:
416 | version "4.8.1"
417 | resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.8.1.tgz#976d3ad905e71b76086f4f0b0d3637fe79b6cda5"
418 | integrity sha512-OSs33Z9yWr148JZcbZd5WiAXhh/n9z8TxQcdMhIOlpN9AhWpLfvVFO73+m77bBABQMaY9XSvIa+qk0jlI7Gcaw==
419 |
420 | pako@^2.0.3:
421 | version "2.1.0"
422 | resolved "https://registry.yarnpkg.com/pako/-/pako-2.1.0.tgz#266cc37f98c7d883545d11335c00fbd4062c9a86"
423 | integrity sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==
424 |
425 | prettier@3.2.5:
426 | version "3.2.5"
427 | resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.2.5.tgz#e52bc3090586e824964a8813b09aba6233b28368"
428 | integrity sha512-3/GWa9aOC0YeD7LUfvOG2NiDyhOWRvt1k+rcKhOuYnMY24iiCphgneUfJDyFXd6rZCAnuLBv6UeAULtrhT/F4A==
429 |
430 | regenerator-runtime@^0.14.0:
431 | version "0.14.1"
432 | resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz#356ade10263f685dda125100cd862c1db895327f"
433 | integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==
434 |
435 | rpc-websockets@^9.0.2:
436 | version "9.0.2"
437 | resolved "https://registry.yarnpkg.com/rpc-websockets/-/rpc-websockets-9.0.2.tgz#4c1568d00b8100f997379a363478f41f8f4b242c"
438 | integrity sha512-YzggvfItxMY3Lwuax5rC18inhbjJv9Py7JXRHxTIi94JOLrqBsSsUUc5bbl5W6c11tXhdfpDPK0KzBhoGe8jjw==
439 | dependencies:
440 | "@swc/helpers" "^0.5.11"
441 | "@types/uuid" "^8.3.4"
442 | "@types/ws" "^8.2.2"
443 | buffer "^6.0.3"
444 | eventemitter3 "^5.0.1"
445 | uuid "^8.3.2"
446 | ws "^8.5.0"
447 | optionalDependencies:
448 | bufferutil "^4.0.1"
449 | utf-8-validate "^5.0.2"
450 |
451 | safe-buffer@^5.0.1:
452 | version "5.2.1"
453 | resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
454 | integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
455 |
456 | snake-case@^3.0.4:
457 | version "3.0.4"
458 | resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c"
459 | integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
460 | dependencies:
461 | dot-case "^3.0.4"
462 | tslib "^2.0.3"
463 |
464 | superstruct@^0.15.4:
465 | version "0.15.5"
466 | resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-0.15.5.tgz#0f0a8d3ce31313f0d84c6096cd4fa1bfdedc9dab"
467 | integrity sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ==
468 |
469 | superstruct@^1.0.4:
470 | version "1.0.4"
471 | resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-1.0.4.tgz#0adb99a7578bd2f1c526220da6571b2d485d91ca"
472 | integrity sha512-7JpaAoX2NGyoFlI9NBh66BQXGONc+uE+MRS5i2iOBKuS4e+ccgMDjATgZldkah+33DakBxDHiss9kvUcGAO8UQ==
473 |
474 | superstruct@^2.0.2:
475 | version "2.0.2"
476 | resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-2.0.2.tgz#3f6d32fbdc11c357deff127d591a39b996300c54"
477 | integrity sha512-uV+TFRZdXsqXTL2pRvujROjdZQ4RAlBUS5BTh9IGm+jTqQntYThciG/qu57Gs69yjnVUSqdxF9YLmSnpupBW9A==
478 |
479 | text-encoding-utf-8@^1.0.2:
480 | version "1.0.2"
481 | resolved "https://registry.yarnpkg.com/text-encoding-utf-8/-/text-encoding-utf-8-1.0.2.tgz#585b62197b0ae437e3c7b5d0af27ac1021e10d13"
482 | integrity sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg==
483 |
484 | "through@>=2.2.7 <3":
485 | version "2.3.8"
486 | resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
487 | integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
488 |
489 | toml@^3.0.0:
490 | version "3.0.0"
491 | resolved "https://registry.yarnpkg.com/toml/-/toml-3.0.0.tgz#342160f1af1904ec9d204d03a5d61222d762c5ee"
492 | integrity sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==
493 |
494 | tr46@~0.0.3:
495 | version "0.0.3"
496 | resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
497 | integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
498 |
499 | tslib@^2.0.3, tslib@^2.4.0:
500 | version "2.6.3"
501 | resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.3.tgz#0438f810ad7a9edcde7a241c3d80db693c8cbfe0"
502 | integrity sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==
503 |
504 | undici-types@~5.26.4:
505 | version "5.26.5"
506 | resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
507 | integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
508 |
509 | utf-8-validate@^5.0.2:
510 | version "5.0.10"
511 | resolved "https://registry.yarnpkg.com/utf-8-validate/-/utf-8-validate-5.0.10.tgz#d7d10ea39318171ca982718b6b96a8d2442571a2"
512 | integrity sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==
513 | dependencies:
514 | node-gyp-build "^4.3.0"
515 |
516 | uuid@^8.3.2:
517 | version "8.3.2"
518 | resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
519 | integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
520 |
521 | webidl-conversions@^3.0.0:
522 | version "3.0.1"
523 | resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
524 | integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==
525 |
526 | whatwg-url@^5.0.0:
527 | version "5.0.0"
528 | resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
529 | integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==
530 | dependencies:
531 | tr46 "~0.0.3"
532 | webidl-conversions "^3.0.0"
533 |
534 | ws@^7.4.5, ws@^7.5.10:
535 | version "7.5.10"
536 | resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.10.tgz#58b5c20dc281633f6c19113f39b349bd8bd558d9"
537 | integrity sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==
538 |
539 | ws@^8.5.0:
540 | version "8.17.1"
541 | resolved "https://registry.yarnpkg.com/ws/-/ws-8.17.1.tgz#9293da530bb548febc95371d90f9c878727d919b"
542 | integrity sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==
543 |
--------------------------------------------------------------------------------
37 |
38 |