@solana/accounts - npm Package Compare versions

Comparing version 2.0.0-experimental.9741939 to 2.0.0-experimental.109615d

dist/index.browser.js

		@@ -19,2 +19,17 @@ import { getBase64Encoder, getBase58Encoder } from '@solana/codecs-strings';
		}
		function accountExists(account) {
		return !("exists" in account) \|\| "exists" in account && account.exists;
		}
		function assertAccountDecoded(account) {
		if (accountExists(account) && account.data instanceof Uint8Array) {
		throw new Error(`Expected account [${account.address}] to be decoded.`);
		}
		}
		function assertAccountsDecoded(accounts) {
		const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
		if (encoded.length > 0) {
		const encodedAddresses = encoded.map((a) => a.address).join(", ");
		throw new Error(`Expected accounts [${encodedAddresses}] to be decoded.`);
		}
		}
		function parseBase64RpcAccount(address, rpcAccount) {
		@@ -76,5 +91,12 @@ if (!rpcAccount)
		}
		function assertAccountsExist(accounts) {
		const missingAccounts = accounts.filter((a) => !a.exists);
		if (missingAccounts.length > 0) {
		const missingAddresses = missingAccounts.map((a) => a.address);
		throw new Error(`Expected accounts [${missingAddresses.join(", ")}] to exist.`);
		}
		}

		export { BASE_ACCOUNT_SIZE, assertAccountExists, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		export { BASE_ACCOUNT_SIZE, assertAccountDecoded, assertAccountExists, assertAccountsDecoded, assertAccountsExist, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.browser.js.map

dist/index.native.js

		@@ -19,2 +19,17 @@ import { getBase64Encoder, getBase58Encoder } from '@solana/codecs-strings';
		}
		function accountExists(account) {
		return !("exists" in account) \|\| "exists" in account && account.exists;
		}
		function assertAccountDecoded(account) {
		if (accountExists(account) && account.data instanceof Uint8Array) {
		throw new Error(`Expected account [${account.address}] to be decoded.`);
		}
		}
		function assertAccountsDecoded(accounts) {
		const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
		if (encoded.length > 0) {
		const encodedAddresses = encoded.map((a) => a.address).join(", ");
		throw new Error(`Expected accounts [${encodedAddresses}] to be decoded.`);
		}
		}
		function parseBase64RpcAccount(address, rpcAccount) {
		@@ -76,5 +91,12 @@ if (!rpcAccount)
		}
		function assertAccountsExist(accounts) {
		const missingAccounts = accounts.filter((a) => !a.exists);
		if (missingAccounts.length > 0) {
		const missingAddresses = missingAccounts.map((a) => a.address);
		throw new Error(`Expected accounts [${missingAddresses.join(", ")}] to exist.`);
		}
		}

		export { BASE_ACCOUNT_SIZE, assertAccountExists, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		export { BASE_ACCOUNT_SIZE, assertAccountDecoded, assertAccountExists, assertAccountsDecoded, assertAccountsExist, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.native.js.map

dist/index.node.js

		@@ -19,2 +19,17 @@ import { getBase64Encoder, getBase58Encoder } from '@solana/codecs-strings';
		}
		function accountExists(account) {
		return !("exists" in account) \|\| "exists" in account && account.exists;
		}
		function assertAccountDecoded(account) {
		if (accountExists(account) && account.data instanceof Uint8Array) {
		throw new Error(`Expected account [${account.address}] to be decoded.`);
		}
		}
		function assertAccountsDecoded(accounts) {
		const encoded = accounts.filter((a) => accountExists(a) && a.data instanceof Uint8Array);
		if (encoded.length > 0) {
		const encodedAddresses = encoded.map((a) => a.address).join(", ");
		throw new Error(`Expected accounts [${encodedAddresses}] to be decoded.`);
		}
		}
		function parseBase64RpcAccount(address, rpcAccount) {
		@@ -76,5 +91,12 @@ if (!rpcAccount)
		}
		function assertAccountsExist(accounts) {
		const missingAccounts = accounts.filter((a) => !a.exists);
		if (missingAccounts.length > 0) {
		const missingAddresses = missingAccounts.map((a) => a.address);
		throw new Error(`Expected accounts [${missingAddresses.join(", ")}] to exist.`);
		}
		}

		export { BASE_ACCOUNT_SIZE, assertAccountExists, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		export { BASE_ACCOUNT_SIZE, assertAccountDecoded, assertAccountExists, assertAccountsDecoded, assertAccountsExist, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fetchJsonParsedAccount, fetchJsonParsedAccounts, parseBase58RpcAccount, parseBase64RpcAccount, parseJsonRpcAccount };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.node.js.map

dist/types/decode-account.d.ts

		@@ -7,2 +7,8 @@ import type { Decoder } from '@solana/codecs-core';
		export declare function decodeAccount<TData extends object, TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>, decoder: Decoder<TData>): MaybeAccount<TData, TAddress>;
		/** Asserts that an account has been decoded. */
		export declare function assertAccountDecoded<TData extends object, TAddress extends string = string>(account: Account<TData \| Uint8Array, TAddress>): asserts account is Account<TData, TAddress>;
		export declare function assertAccountDecoded<TData extends object, TAddress extends string = string>(account: MaybeAccount<TData \| Uint8Array, TAddress>): asserts account is MaybeAccount<TData, TAddress>;
		/** Asserts that all accounts have been decoded. */
		export declare function assertAccountsDecoded<TData extends object, TAddress extends string = string>(accounts: Account<TData \| Uint8Array, TAddress>[]): asserts accounts is Account<TData, TAddress>[];
		export declare function assertAccountsDecoded<TData extends object, TAddress extends string = string>(accounts: MaybeAccount<TData \| Uint8Array, TAddress>[]): asserts accounts is MaybeAccount<TData, TAddress>[];
		//# sourceMappingURL=decode-account.d.ts.map

dist/types/maybe-account.d.ts

		@@ -16,2 +16,6 @@ import { Address } from '@solana/addresses';
		};
		/** Asserts that all accounts that may or may not exist, actually all exist. */
		export declare function assertAccountsExist<TData extends object \| Uint8Array, TAddress extends string = string>(accounts: MaybeAccount<TData, TAddress>[]): asserts accounts is (Account<TData, TAddress> & {
		exists: true;
		})[];
		//# sourceMappingURL=maybe-account.d.ts.map

package.json

		{
		"name": "@solana/accounts",
		"version": "2.0.0-experimental.9741939",
		"version": "2.0.0-experimental.109615d",
		"description": "Helpers for representing, fetching and decoding Solana accounts",
		@@ -49,8 +49,8 @@ "exports": {
		"dependencies": {
		"@solana/addresses": "2.0.0-experimental.9741939",
		"@solana/codecs-core": "2.0.0-experimental.9741939",
		"@solana/codecs-strings": "2.0.0-experimental.9741939",
		"@solana/rpc-core": "2.0.0-experimental.9741939",
		"@solana/rpc-transport": "2.0.0-experimental.9741939",
		"@solana/rpc-types": "2.0.0-experimental.9741939"
		"@solana/addresses": "2.0.0-experimental.109615d",
		"@solana/codecs-core": "2.0.0-experimental.109615d",
		"@solana/codecs-strings": "2.0.0-experimental.109615d",
		"@solana/rpc-core": "2.0.0-experimental.109615d",
		"@solana/rpc-transport": "2.0.0-experimental.109615d",
		"@solana/rpc-types": "2.0.0-experimental.109615d"
		},
		@@ -57,0 +57,0 @@ "devDependencies": {

README.md

		@@ -150,2 +150,17 @@ [![npm][npm-image]][npm-url]

		### `assertAccountsExist()`

		Given an array of `MaybeAccount`s, this function asserts that all the accounts
		exist and allows them to be used as an array of `Account`s going forward.

		```ts
		const myAccounts: MaybeEncodedAccount<Address>[];
		assertAccountsExist(myAccounts);

		// Now we can use them as an array of accounts
		for (const a of myAccounts) {
		a satisfies EncodedAccount<Address>;
		}
		```

		### `parseBase64RpcAccount()`
		@@ -256,1 +271,45 @@
		```

		### `assertAccountDecoded()`

		This function asserts that an account stores decoded data, ie not a Uint8Array. Note that it does not check the shape of the data matches the decoded type, only that it is not a Uint8Array.

		```ts
		type MyAccountData = { name: string; age: number };

		const myAccount: Account<MyAccountData \| Uint8Array, '1234..5678'>;
		assertAccountDecoded(myAccount);

		// now the account data can be used as MyAccountData
		account.data satisfies MyAccountData;
		```

		This is particularly useful for narrowing the result of fetching a JSON parsed account.


		```ts
		const account: MaybeAccount<MockData \| Uint8Array> = await fetchJsonParsedAccount<MockData>(
		rpc,
		'1234..5678' as Address,
		)

		assertAccountDecoded(account);
		// now we have a MaybeAccount<MockData>
		account satisfies MaybeAccount<MockData>
		```

		### `assertAccountsDecoded`

		This function asserts that all input accounts store decoded data, ie not a Uint8Array. As with `assertAccountDecoded` it does not check the shape of the data matches the decoded type, only that it is not a Uint8Array.

		```ts
		type MyAccountData = { name: string; age: number };

		const myAccounts: Account<MyAccountData \| Uint8Array, Address>[];
		assertAccountsDecoded(myAccounts);

		// now the account data can be used as MyAccountData
		for(const a of account) {
		account.data satisfies MyAccountData;
		}
		```

./dist/index.node.cjs