@solana/transactions - npm Package Compare versions

Comparing version 2.0.0-experimental.6cedd3a to 2.0.0-experimental.71b920d

dist/types/accounts.d.ts

dist/types/compile-address-table-lookups.d.ts

dist/types/compile-header.d.ts

dist/types/compile-instructions.d.ts

dist/types/compile-lifetime-token.d.ts

dist/types/compile-static-accounts.d.ts

dist/types/message.d.ts

dist/types/serializers/address-table-lookup.d.ts

dist/types/serializers/header.d.ts

dist/types/serializers/instruction.d.ts

dist/types/serializers/message.d.ts

dist/types/serializers/transaction-version.d.ts

dist/types/serializers/unimplemented.d.ts

558

dist/index.browser.js

		@@ -0,1 +1,7 @@
		import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
		import { struct, mapSerializer, array, shortU16, string, base58, u8, bytes } from '@metaplex-foundation/umi-serializers';

		// ../build-scripts/env-shim.ts
		var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();

		// src/create-transaction.ts
		@@ -73,4 +79,554 @@ function createTransaction({

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
		// ../instructions/dist/index.browser.js
		var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
		AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
		3] = "WRITABLE_SIGNER";
		AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
		2] = "READONLY_SIGNER";
		AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
		1] = "WRITABLE";
		AccountRole2[AccountRole2["READONLY"] = /* 0 */
		0] = "READONLY";
		return AccountRole2;
		})(AccountRole \|\| {});
		var IS_WRITABLE_BITMASK = 1;
		function isSignerRole(role) {
		return role >= 2;
		}
		function isWritableRole(role) {
		return (role & IS_WRITABLE_BITMASK) !== 0;
		}
		function mergeRoles(roleA, roleB) {
		return roleA \| roleB;
		}
		function upsert(addressMap, address, update) {
		addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
		}
		var TYPE = Symbol("AddressMapTypeProperty");
		function getAddressMapFromInstructions(feePayer, instructions) {
		const addressMap = {
		[feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
		};
		const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
		for (const instruction of instructions) {
		upsert(addressMap, instruction.programAddress, (entry) => {
		addressesOfInvokedPrograms.add(instruction.programAddress);
		if (TYPE in entry) {
		if (isWritableRole(entry.role)) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
		);
		default:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		}
		if (entry[TYPE] === 2 /* STATIC */) {
		return entry;
		}
		}
		return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
		});
		let addressComparator;
		if (!instruction.accounts) {
		continue;
		}
		for (const account of instruction.accounts) {
		upsert(addressMap, account.address, (entry) => {
		const {
		// eslint-disable-next-line @typescript-eslint/no-unused-vars
		address: _,
		...accountMeta
		} = account;
		if (TYPE in entry) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		return entry;
		case 1 /* LOOKUP_TABLE */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if ("lookupTableAddress" in accountMeta) {
		const shouldReplaceEntry = (
		// Consider using the new LOOKUP_TABLE if its address is different...
		entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
		(addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator()))(
		accountMeta.lookupTableAddress,
		entry.lookupTableAddress
		) < 0
		);
		if (shouldReplaceEntry) {
		return {
		[TYPE]: 1 /* LOOKUP_TABLE */,
		...accountMeta,
		role: nextRole
		};
		}
		} else if (isSignerRole(accountMeta.role)) {
		return {
		[TYPE]: 2 /* STATIC */,
		role: nextRole
		};
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		case 2 /* STATIC */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if (
		// Check to see if this address represents a program that is invoked
		// in this transaction.
		addressesOfInvokedPrograms.has(account.address)
		) {
		if (isWritableRole(accountMeta.role)) {
		throw new Error(
		`This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		} else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
		// long as they are not require to sign the transaction.
		!isSignerRole(entry.role)) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */,
		role: nextRole
		};
		} else {
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		}
		}
		}
		if ("lookupTableAddress" in accountMeta) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */
		};
		} else {
		return {
		...accountMeta,
		[TYPE]: 2 /* STATIC */
		};
		}
		});
		}
		}
		return addressMap;
		}
		function getOrderedAccountsFromAddressMap(addressMap) {
		let addressComparator;
		const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
		if (leftEntry[TYPE] !== rightEntry[TYPE]) {
		if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
		return -1;
		} else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
		return 1;
		} else if (leftEntry[TYPE] === 2 /* STATIC */) {
		return -1;
		} else if (rightEntry[TYPE] === 2 /* STATIC */) {
		return 1;
		}
		}
		const leftIsSigner = isSignerRole(leftEntry.role);
		if (leftIsSigner !== isSignerRole(rightEntry.role)) {
		return leftIsSigner ? -1 : 1;
		}
		const leftIsWritable = isWritableRole(leftEntry.role);
		if (leftIsWritable !== isWritableRole(rightEntry.role)) {
		return leftIsWritable ? -1 : 1;
		}
		addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator());
		if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE / && rightEntry[TYPE] === 1 / LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
		return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
		} else {
		return addressComparator(leftAddress, rightAddress);
		}
		}).map(([address, addressMeta]) => ({
		address,
		...addressMeta
		}));
		return orderedAccounts;
		}
		function getCompiledAddressTableLookups(orderedAccounts) {
		var _a;
		const index = {};
		for (const account of orderedAccounts) {
		if (!("lookupTableAddress" in account)) {
		continue;
		}
		const entry = index[_a = account.lookupTableAddress] \|\| (index[_a] = {
		readableIndices: [],
		writableIndices: []
		});
		if (account.role === AccountRole.WRITABLE) {
		entry.writableIndices.push(account.addressIndex);
		} else {
		entry.readableIndices.push(account.addressIndex);
		}
		}
		return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
		lookupTableAddress,
		...index[lookupTableAddress]
		}));
		}

		// src/compile-header.ts
		function getCompiledMessageHeader(orderedAccounts) {
		let numReadonlyNonSignerAccounts = 0;
		let numReadonlySignerAccounts = 0;
		let numSignerAccounts = 0;
		for (const account of orderedAccounts) {
		if ("lookupTableAddress" in account) {
		break;
		}
		const accountIsWritable = isWritableRole(account.role);
		if (isSignerRole(account.role)) {
		numSignerAccounts++;
		if (!accountIsWritable) {
		numReadonlySignerAccounts++;
		}
		} else if (!accountIsWritable) {
		numReadonlyNonSignerAccounts++;
		}
		}
		return {
		numReadonlyNonSignerAccounts,
		numReadonlySignerAccounts,
		numSignerAccounts
		};
		}

		// src/compile-instructions.ts
		function getAccountIndex(orderedAccounts) {
		const out = {};
		for (const [index, account] of orderedAccounts.entries()) {
		out[account.address] = index;
		}
		return out;
		}
		function getCompiledInstructions(instructions, orderedAccounts) {
		const accountIndex = getAccountIndex(orderedAccounts);
		return instructions.map(({ accounts, data, programAddress }) => {
		return {
		programAddressIndex: accountIndex[programAddress],
		...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
		...data ? { data } : null
		};
		});
		}

		// src/compile-lifetime-token.ts
		function getCompiledLifetimeToken(lifetimeConstraint) {
		if ("nonce" in lifetimeConstraint) {
		return lifetimeConstraint.nonce;
		}
		return lifetimeConstraint.blockhash;
		}

		// src/compile-static-accounts.ts
		function getCompiledStaticAccounts(orderedAccounts) {
		const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
		const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
		return orderedStaticAccounts.map(({ address }) => address);
		}

		// src/message.ts
		function compileMessage(transaction) {
		const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
		const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
		return {
		...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
		header: getCompiledMessageHeader(orderedAccounts),
		instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
		lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
		staticAccounts: getCompiledStaticAccounts(orderedAccounts),
		version: transaction.version
		};
		}
		function getAddressTableLookupCodec() {
		return struct(
		[
		[
		"lookupTableAddress",
		getBase58EncodedAddressCodec(
		__DEV__ ? {
		description: "The address of the address lookup table account from which instruction addresses should be looked up"
		} : void 0
		)
		],
		[
		"writableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as writeable"
		} : null,
		size: shortU16()
		})
		],
		[
		"readableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as read-only"
		} : void 0,
		size: shortU16()
		})
		]
		],
		__DEV__ ? {
		description: "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it"
		} : void 0
		);
		}
		function getMessageHeaderCodec() {
		return struct(
		[
		[
		"numSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
		} : void 0
		)
		],
		[
		"numReadonlySignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
		} : void 0
		)
		],
		[
		"numReadonlyNonSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
		} : void 0
		)
		]
		],
		__DEV__ ? {
		description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
		} : void 0
		);
		}
		function getInstructionCodec() {
		return mapSerializer(
		struct([
		[
		"programAddressIndex",
		u8(
		__DEV__ ? {
		description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
		} : void 0
		)
		],
		[
		"addressIndices",
		array(
		u8({
		description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
		}),
		{
		description: __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "",
		size: shortU16()
		}
		)
		],
		[
		"data",
		bytes({
		description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
		size: shortU16()
		})
		]
		]),
		(value) => {
		if (value.addressIndices !== void 0 && value.data !== void 0) {
		return value;
		}
		return {
		...value,
		addressIndices: value.addressIndices ?? [],
		data: value.data ?? new Uint8Array(0)
		};
		},
		(value) => {
		if (value.addressIndices.length && value.data.byteLength) {
		return value;
		}
		const { addressIndices, data, ...rest } = value;
		return {
		...rest,
		...addressIndices.length ? { addressIndices } : null,
		...data.byteLength ? { data } : null
		};
		}
		);
		}

		// src/serializers/unimplemented.ts
		function getError(type, name) {
		const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
		return new Error(
		`No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
		);
		}
		function getUnimplementedDecoder(name) {
		return () => {
		throw getError("decoder", name);
		};
		}

		// src/serializers/transaction-version.ts
		var VERSION_FLAG_MASK = 128;
		var BASE_CONFIG = {
		description: __DEV__ ? "A single byte that encodes the version of the transaction" : "",
		fixedSize: null,
		maxSize: 1
		};
		function deserialize(bytes2, offset = 0) {
		const firstByte = bytes2[offset];
		if ((firstByte & VERSION_FLAG_MASK) === 0) {
		return ["legacy", offset];
		} else {
		const version = firstByte ^ VERSION_FLAG_MASK;
		return [version, offset + 1];
		}
		}
		function serialize(value) {
		if (value === "legacy") {
		return new Uint8Array();
		}
		if (value < 0 \|\| value > 127) {
		throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
		}
		return new Uint8Array([value \| VERSION_FLAG_MASK]);
		}
		function getTransactionVersionCodec() {
		return {
		...BASE_CONFIG,
		deserialize,
		serialize
		};
		}

		// src/serializers/message.ts
		var BASE_CONFIG2 = {
		description: __DEV__ ? "The wire format of a Solana transaction message" : "",
		fixedSize: null,
		maxSize: null
		};
		function serialize2(compiledMessage) {
		if (compiledMessage.version === "legacy") {
		return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
		} else {
		return mapSerializer(
		struct([
		...getPreludeStructSerializerTuple(),
		["addressTableLookups", getAddressTableLookupsSerializer()]
		]),
		(value) => {
		if (value.version === "legacy") {
		return value;
		}
		return {
		...value,
		addressTableLookups: value.addressTableLookups ?? []
		};
		}
		).serialize(compiledMessage);
		}
		}
		function getPreludeStructSerializerTuple() {
		return [
		["version", getTransactionVersionCodec()],
		["header", getMessageHeaderCodec()],
		[
		"staticAccounts",
		array(getBase58EncodedAddressCodec(), {
		description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
		size: shortU16()
		})
		],
		[
		"lifetimeToken",
		string({
		description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
		encoding: base58,
		size: 32
		})
		],
		[
		"instructions",
		array(getInstructionCodec(), {
		description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
		size: shortU16()
		})
		]
		];
		}
		function getAddressTableLookupsSerializer() {
		return array(getAddressTableLookupCodec(), {
		...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
		size: shortU16()
		});
		}
		function getCompiledMessageEncoder() {
		return {
		...BASE_CONFIG2,
		deserialize: getUnimplementedDecoder("CompiledMessage"),
		serialize: serialize2
		};
		}

		// src/signatures.ts
		async function getCompiledMessageSignature(message, secretKey) {
		const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
		const signature = await signBytes(secretKey, wireMessageBytes);
		return signature;
		}
		async function signTransaction(keyPair, transaction) {
		const compiledMessage = compileMessage(transaction);
		const [signerPublicKey, signature] = await Promise.all([
		getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
		getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
		]);
		const nextSignatures = {
		..."signatures" in transaction ? transaction.signatures : null,
		...{ [signerPublicKey]: signature }
		};
		const out = {
		...transaction,
		signatures: nextSignatures
		};
		Object.freeze(out);
		return out;
		}

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.browser.js.map

1102

dist/index.development.js

		@@ -5,2 +5,9 @@ this.globalThis = this.globalThis \|\| {};

		var __defProp = Object.defineProperty;
		var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
		var __publicField = (obj, key, value) => {
		__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
		return value;
		};

		// src/create-transaction.ts
		@@ -78,2 +85,1096 @@ function createTransaction({

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
		var mergeBytes = (bytesArr) => {
		const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
		const result = new Uint8Array(totalLength);
		let offset = 0;
		bytesArr.forEach((arr) => {
		result.set(arr, offset);
		offset += arr.length;
		});
		return result;
		};
		var padBytes = (bytes2, length) => {
		if (bytes2.length >= length)
		return bytes2;
		const paddedBytes = new Uint8Array(length).fill(0);
		paddedBytes.set(bytes2);
		return paddedBytes;
		};
		var fixBytes = (bytes2, length) => padBytes(bytes2.slice(0, length), length);

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
		var DeserializingEmptyBufferError = class extends Error {
		constructor(serializer) {
		super(`Serializer [${serializer}] cannot deserialize empty buffers.`);
		__publicField(this, "name", "DeserializingEmptyBufferError");
		}
		};
		var NotEnoughBytesError = class extends Error {
		constructor(serializer, expected, actual) {
		super(`Serializer [${serializer}] expected ${expected} bytes, got ${actual}.`);
		__publicField(this, "name", "NotEnoughBytesError");
		}
		};
		var ExpectedFixedSizeSerializerError = class extends Error {
		constructor(message) {
		message ?? (message = "Expected a fixed-size serializer, got a variable-size one.");
		super(message);
		__publicField(this, "name", "ExpectedFixedSizeSerializerError");
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
		function fixSerializer(serializer, fixedBytes, description) {
		return {
		description: description ?? `fixed(${fixedBytes}, ${serializer.description})`,
		fixedSize: fixedBytes,
		maxSize: fixedBytes,
		serialize: (value) => fixBytes(serializer.serialize(value), fixedBytes),
		deserialize: (buffer, offset = 0) => {
		buffer = buffer.slice(offset, offset + fixedBytes);
		if (buffer.length < fixedBytes) {
		throw new NotEnoughBytesError("fixSerializer", fixedBytes, buffer.length);
		}
		if (serializer.fixedSize !== null) {
		buffer = fixBytes(buffer, serializer.fixedSize);
		}
		const [value] = serializer.deserialize(buffer, 0);
		return [value, offset + fixedBytes];
		}
		};
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/mapSerializer.mjs
		function mapSerializer(serializer, unmap, map) {
		return {
		description: serializer.description,
		fixedSize: serializer.fixedSize,
		maxSize: serializer.maxSize,
		serialize: (value) => serializer.serialize(unmap(value)),
		deserialize: (buffer, offset = 0) => {
		const [value, length] = serializer.deserialize(buffer, offset);
		return map ? [map(value, buffer, offset), length] : [value, length];
		}
		};
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
		var InvalidBaseStringError = class extends Error {
		constructor(value, base, cause) {
		const message = `Expected a string of base ${base}, got [${value}].`;
		super(message);
		__publicField(this, "name", "InvalidBaseStringError");
		this.cause = cause;
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
		var baseX = (alphabet) => {
		const base = alphabet.length;
		const baseBigInt = BigInt(base);
		return {
		description: `base${base}`,
		fixedSize: null,
		maxSize: null,
		serialize(value) {
		if (!value.match(new RegExp(`^[${alphabet}]*$`))) {
		throw new InvalidBaseStringError(value, base);
		}
		if (value === "")
		return new Uint8Array();
		const chars = [...value];
		let trailIndex = chars.findIndex((c) => c !== alphabet[0]);
		trailIndex = trailIndex === -1 ? chars.length : trailIndex;
		const leadingZeroes = Array(trailIndex).fill(0);
		if (trailIndex === chars.length)
		return Uint8Array.from(leadingZeroes);
		const tailChars = chars.slice(trailIndex);
		let base10Number = 0n;
		let baseXPower = 1n;
		for (let i = tailChars.length - 1; i >= 0; i -= 1) {
		base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));
		baseXPower *= baseBigInt;
		}
		const tailBytes = [];
		while (base10Number > 0n) {
		tailBytes.unshift(Number(base10Number % 256n));
		base10Number /= 256n;
		}
		return Uint8Array.from(leadingZeroes.concat(tailBytes));
		},
		deserialize(buffer, offset = 0) {
		if (buffer.length === 0)
		return ["", 0];
		const bytes2 = buffer.slice(offset);
		let trailIndex = bytes2.findIndex((n) => n !== 0);
		trailIndex = trailIndex === -1 ? bytes2.length : trailIndex;
		const leadingZeroes = alphabet[0].repeat(trailIndex);
		if (trailIndex === bytes2.length)
		return [leadingZeroes, buffer.length];
		let base10Number = bytes2.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
		const tailChars = [];
		while (base10Number > 0n) {
		tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);
		base10Number /= baseBigInt;
		}
		return [leadingZeroes + tailChars.join(""), buffer.length];
		}
		};
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
		var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
		var removeNullCharacters = (value) => (
		// eslint-disable-next-line no-control-regex
		value.replace(/\u0000/g, "")
		);

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
		var utf8 = {
		description: "utf8",
		fixedSize: null,
		maxSize: null,
		serialize(value) {
		return new TextEncoder().encode(value);
		},
		deserialize(buffer, offset = 0) {
		const value = new TextDecoder().decode(buffer.slice(offset));
		return [removeNullCharacters(value), buffer.length];
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
		var Endian;
		(function(Endian2) {
		Endian2["Little"] = "le";
		Endian2["Big"] = "be";
		})(Endian \|\| (Endian = {}));

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
		var NumberOutOfRangeError = class extends RangeError {
		constructor(serializer, min, max, actual) {
		super(`Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`);
		__publicField(this, "name", "NumberOutOfRangeError");
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
		function numberFactory(input) {
		let littleEndian;
		let defaultDescription = input.name;
		if (input.size > 1) {
		littleEndian = !("endian" in input.options) \|\| input.options.endian === Endian.Little;
		defaultDescription += littleEndian ? "(le)" : "(be)";
		}
		return {
		description: input.options.description ?? defaultDescription,
		fixedSize: input.size,
		maxSize: input.size,
		serialize(value) {
		if (input.range) {
		assertRange(input.name, input.range[0], input.range[1], value);
		}
		const buffer = new ArrayBuffer(input.size);
		input.set(new DataView(buffer), value, littleEndian);
		return new Uint8Array(buffer);
		},
		deserialize(bytes2, offset = 0) {
		const slice = bytes2.slice(offset, offset + input.size);
		assertEnoughBytes("i8", slice, input.size);
		const view = toDataView(slice);
		return [input.get(view, littleEndian), offset + input.size];
		}
		};
		}
		var toArrayBuffer = (array2) => array2.buffer.slice(array2.byteOffset, array2.byteLength + array2.byteOffset);
		var toDataView = (array2) => new DataView(toArrayBuffer(array2));
		var assertRange = (serializer, min, max, value) => {
		if (value < min \|\| value > max) {
		throw new NumberOutOfRangeError(serializer, min, max, value);
		}
		};
		var assertEnoughBytes = (serializer, bytes2, expected) => {
		if (bytes2.length === 0) {
		throw new DeserializingEmptyBufferError(serializer);
		}
		if (bytes2.length < expected) {
		throw new NotEnoughBytesError(serializer, expected, bytes2.length);
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u8.mjs
		var u8 = (options = {}) => numberFactory({
		name: "u8",
		size: 1,
		range: [0, Number("0xff")],
		set: (view, value) => view.setUint8(0, Number(value)),
		get: (view) => view.getUint8(0),
		options
		});

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
		var u32 = (options = {}) => numberFactory({
		name: "u32",
		size: 4,
		range: [0, Number("0xffffffff")],
		set: (view, value, le) => view.setUint32(0, Number(value), le),
		get: (view, le) => view.getUint32(0, le),
		options
		});

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/shortU16.mjs
		var shortU16 = (options = {}) => ({
		description: options.description ?? "shortU16",
		fixedSize: null,
		maxSize: 3,
		serialize: (value) => {
		assertRange("shortU16", 0, 65535, value);
		const bytes2 = [0];
		for (let ii = 0; ; ii += 1) {
		const alignedValue = value >> ii * 7;
		if (alignedValue === 0) {
		break;
		}
		const nextSevenBits = 127 & alignedValue;
		bytes2[ii] = nextSevenBits;
		if (ii > 0) {
		bytes2[ii - 1] \|= 128;
		}
		}
		return new Uint8Array(bytes2);
		},
		deserialize: (bytes2, offset = 0) => {
		let value = 0;
		let byteCount = 0;
		while (++byteCount) {
		const byteIndex = byteCount - 1;
		const currentByte = bytes2[offset + byteIndex];
		const nextSevenBits = 127 & currentByte;
		value \|= nextSevenBits << byteIndex * 7;
		if ((currentByte & 128) === 0) {
		break;
		}
		}
		return [value, offset + byteCount];
		}
		});

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/errors.mjs
		var InvalidNumberOfItemsError = class extends Error {
		constructor(serializer, expected, actual) {
		super(`Expected [${serializer}] to have ${expected} items, got ${actual}.`);
		__publicField(this, "name", "InvalidNumberOfItemsError");
		}
		};
		var InvalidArrayLikeRemainderSizeError = class extends Error {
		constructor(remainderSize, itemSize) {
		super(`The remainder of the buffer (${remainderSize} bytes) cannot be split into chunks of ${itemSize} bytes. Serializers of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainderSize} modulo ${itemSize} should be equal to zero.`);
		__publicField(this, "name", "InvalidArrayLikeRemainderSizeError");
		}
		};
		var UnrecognizedArrayLikeSerializerSizeError = class extends Error {
		constructor(size) {
		super(`Unrecognized array-like serializer size: ${JSON.stringify(size)}`);
		__publicField(this, "name", "UnrecognizedArrayLikeSerializerSizeError");
		}
		};

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/sumSerializerSizes.mjs
		function sumSerializerSizes(sizes) {
		return sizes.reduce((all, size) => all === null \|\| size === null ? null : all + size, 0);
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
		function getResolvedSize(size, childrenSizes, bytes2, offset) {
		if (typeof size === "number") {
		return [size, offset];
		}
		if (typeof size === "object") {
		return size.deserialize(bytes2, offset);
		}
		if (size === "remainder") {
		const childrenSize = sumSerializerSizes(childrenSizes);
		if (childrenSize === null) {
		throw new ExpectedFixedSizeSerializerError('Serializers of "remainder" size must have fixed-size items.');
		}
		const remainder = bytes2.slice(offset).length;
		if (remainder % childrenSize !== 0) {
		throw new InvalidArrayLikeRemainderSizeError(remainder, childrenSize);
		}
		return [remainder / childrenSize, offset];
		}
		throw new UnrecognizedArrayLikeSerializerSizeError(size);
		}
		function getSizeDescription(size) {
		return typeof size === "object" ? size.description : `${size}`;
		}
		function getSizeFromChildren(size, childrenSizes) {
		if (typeof size !== "number")
		return null;
		if (size === 0)
		return 0;
		const childrenSize = sumSerializerSizes(childrenSizes);
		return childrenSize === null ? null : childrenSize * size;
		}
		function getSizePrefix(size, realSize) {
		return typeof size === "object" ? size.serialize(realSize) : new Uint8Array();
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/array.mjs
		function array(item, options = {}) {
		const size = options.size ?? u32();
		if (size === "remainder" && item.fixedSize === null) {
		throw new ExpectedFixedSizeSerializerError('Serializers of "remainder" size must have fixed-size items.');
		}
		return {
		description: options.description ?? `array(${item.description}; ${getSizeDescription(size)})`,
		fixedSize: getSizeFromChildren(size, [item.fixedSize]),
		maxSize: getSizeFromChildren(size, [item.maxSize]),
		serialize: (value) => {
		if (typeof size === "number" && value.length !== size) {
		throw new InvalidNumberOfItemsError("array", size, value.length);
		}
		return mergeBytes([getSizePrefix(size, value.length), ...value.map((v) => item.serialize(v))]);
		},
		deserialize: (bytes2, offset = 0) => {
		if (typeof size === "object" && bytes2.slice(offset).length === 0) {
		return [[], offset];
		}
		const [resolvedSize, newOffset] = getResolvedSize(size, [item.fixedSize], bytes2, offset);
		offset = newOffset;
		const values = [];
		for (let i = 0; i < resolvedSize; i += 1) {
		const [value, newOffset2] = item.deserialize(bytes2, offset);
		values.push(value);
		offset = newOffset2;
		}
		return [values, offset];
		}
		};
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/bytes.mjs
		function bytes(options = {}) {
		const size = options.size ?? "variable";
		const description = options.description ?? `bytes(${getSizeDescription(size)})`;
		const byteSerializer = {
		description,
		fixedSize: null,
		maxSize: null,
		serialize: (value) => new Uint8Array(value),
		deserialize: (bytes2, offset = 0) => {
		const slice = bytes2.slice(offset);
		return [slice, offset + slice.length];
		}
		};
		if (size === "variable") {
		return byteSerializer;
		}
		if (typeof size === "number") {
		return fixSerializer(byteSerializer, size, description);
		}
		return {
		description,
		fixedSize: null,
		maxSize: null,
		serialize: (value) => {
		const contentBytes = byteSerializer.serialize(value);
		const lengthBytes = size.serialize(contentBytes.length);
		return mergeBytes([lengthBytes, contentBytes]);
		},
		deserialize: (buffer, offset = 0) => {
		if (buffer.slice(offset).length === 0) {
		throw new DeserializingEmptyBufferError("bytes");
		}
		const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);
		const length = Number(lengthBigInt);
		offset = lengthOffset;
		const contentBuffer = buffer.slice(offset, offset + length);
		if (contentBuffer.length < length) {
		throw new NotEnoughBytesError("bytes", length, contentBuffer.length);
		}
		const [value, contentOffset] = byteSerializer.deserialize(contentBuffer);
		offset += contentOffset;
		return [value, offset];
		}
		};
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
		function string(options = {}) {
		const size = options.size ?? u32();
		const encoding = options.encoding ?? utf8;
		const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
		if (size === "variable") {
		return {
		...encoding,
		description
		};
		}
		if (typeof size === "number") {
		return fixSerializer(encoding, size, description);
		}
		return {
		description,
		fixedSize: null,
		maxSize: null,
		serialize: (value) => {
		const contentBytes = encoding.serialize(value);
		const lengthBytes = size.serialize(contentBytes.length);
		return mergeBytes([lengthBytes, contentBytes]);
		},
		deserialize: (buffer, offset = 0) => {
		if (buffer.slice(offset).length === 0) {
		throw new DeserializingEmptyBufferError("string");
		}
		const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);
		const length = Number(lengthBigInt);
		offset = lengthOffset;
		const contentBuffer = buffer.slice(offset, offset + length);
		if (contentBuffer.length < length) {
		throw new NotEnoughBytesError("string", length, contentBuffer.length);
		}
		const [value, contentOffset] = encoding.deserialize(contentBuffer);
		offset += contentOffset;
		return [value, offset];
		}
		};
		}

		// ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.2/node_modules/@metaplex-foundation/umi-serializers/dist/esm/struct.mjs
		function struct(fields, options = {}) {
		const fieldDescriptions = fields.map(([name, serializer]) => `${String(name)}: ${serializer.description}`).join(", ");
		return {
		description: options.description ?? `struct(${fieldDescriptions})`,
		fixedSize: sumSerializerSizes(fields.map(([, field]) => field.fixedSize)),
		maxSize: sumSerializerSizes(fields.map(([, field]) => field.maxSize)),
		serialize: (struct2) => {
		const fieldBytes = fields.map(([key, serializer]) => serializer.serialize(struct2[key]));
		return mergeBytes(fieldBytes);
		},
		deserialize: (bytes2, offset = 0) => {
		const struct2 = {};
		fields.forEach(([key, serializer]) => {
		const [value, newOffset] = serializer.deserialize(bytes2, offset);
		offset = newOffset;
		struct2[key] = value;
		});
		return [struct2, offset];
		}
		};
		}
		function getBase58EncodedAddressCodec(config) {
		return string({
		description: config?.description ?? ("A 32-byte account address" ),
		encoding: base58,
		size: 32
		});
		}
		function getBase58EncodedAddressComparator() {
		return new Intl.Collator("en", {
		caseFirst: "lower",
		ignorePunctuation: false,
		localeMatcher: "best fit",
		numeric: false,
		sensitivity: "variant",
		usage: "sort"
		}).compare;
		}
		function assertIsSecureContext() {
		if (!globalThis.isSecureContext) {
		throw new Error(
		"Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts"
		);
		}
		}
		async function assertKeyExporterIsAvailable() {
		assertIsSecureContext();
		if (typeof globalThis.crypto === "undefined" \|\| typeof globalThis.crypto.subtle?.exportKey !== "function") {
		throw new Error("No key export implementation could be found");
		}
		}
		async function assertSigningCapabilityIsAvailable() {
		assertIsSecureContext();
		if (typeof globalThis.crypto === "undefined" \|\| typeof globalThis.crypto.subtle?.sign !== "function") {
		throw new Error("No signing implementation could be found");
		}
		}
		async function getBase58EncodedAddressFromPublicKey(publicKey) {
		await assertKeyExporterIsAvailable();
		if (publicKey.type !== "public" \|\| publicKey.algorithm.name !== "Ed25519") {
		throw new Error("The `CryptoKey` must be an `Ed25519` public key");
		}
		const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
		const [base58EncodedAddress] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes));
		return base58EncodedAddress;
		}
		async function signBytes(key, data) {
		await assertSigningCapabilityIsAvailable();
		const signedData = await crypto.subtle.sign("Ed25519", key, data);
		return new Uint8Array(signedData);
		}

		// ../instructions/dist/index.browser.js
		var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
		AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
		3] = "WRITABLE_SIGNER";
		AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
		2] = "READONLY_SIGNER";
		AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
		1] = "WRITABLE";
		AccountRole2[AccountRole2["READONLY"] = /* 0 */
		0] = "READONLY";
		return AccountRole2;
		})(AccountRole \|\| {});
		var IS_WRITABLE_BITMASK = 1;
		function isSignerRole(role) {
		return role >= 2;
		}
		function isWritableRole(role) {
		return (role & IS_WRITABLE_BITMASK) !== 0;
		}
		function mergeRoles(roleA, roleB) {
		return roleA \| roleB;
		}

		// src/accounts.ts
		function upsert(addressMap, address, update) {
		addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
		}
		var TYPE = Symbol("AddressMapTypeProperty");
		function getAddressMapFromInstructions(feePayer, instructions) {
		const addressMap = {
		[feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
		};
		const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
		for (const instruction of instructions) {
		upsert(addressMap, instruction.programAddress, (entry) => {
		addressesOfInvokedPrograms.add(instruction.programAddress);
		if (TYPE in entry) {
		if (isWritableRole(entry.role)) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
		);
		default:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		}
		if (entry[TYPE] === 2 /* STATIC */) {
		return entry;
		}
		}
		return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
		});
		let addressComparator;
		if (!instruction.accounts) {
		continue;
		}
		for (const account of instruction.accounts) {
		upsert(addressMap, account.address, (entry) => {
		const {
		// eslint-disable-next-line @typescript-eslint/no-unused-vars
		address: _,
		...accountMeta
		} = account;
		if (TYPE in entry) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		return entry;
		case 1 /* LOOKUP_TABLE */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if ("lookupTableAddress" in accountMeta) {
		const shouldReplaceEntry = (
		// Consider using the new LOOKUP_TABLE if its address is different...
		entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
		(addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator()))(
		accountMeta.lookupTableAddress,
		entry.lookupTableAddress
		) < 0
		);
		if (shouldReplaceEntry) {
		return {
		[TYPE]: 1 /* LOOKUP_TABLE */,
		...accountMeta,
		role: nextRole
		};
		}
		} else if (isSignerRole(accountMeta.role)) {
		return {
		[TYPE]: 2 /* STATIC */,
		role: nextRole
		};
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		case 2 /* STATIC */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if (
		// Check to see if this address represents a program that is invoked
		// in this transaction.
		addressesOfInvokedPrograms.has(account.address)
		) {
		if (isWritableRole(accountMeta.role)) {
		throw new Error(
		`This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		} else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
		// long as they are not require to sign the transaction.
		!isSignerRole(entry.role)) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */,
		role: nextRole
		};
		} else {
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		}
		}
		}
		if ("lookupTableAddress" in accountMeta) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */
		};
		} else {
		return {
		...accountMeta,
		[TYPE]: 2 /* STATIC */
		};
		}
		});
		}
		}
		return addressMap;
		}
		function getOrderedAccountsFromAddressMap(addressMap) {
		let addressComparator;
		const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
		if (leftEntry[TYPE] !== rightEntry[TYPE]) {
		if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
		return -1;
		} else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
		return 1;
		} else if (leftEntry[TYPE] === 2 /* STATIC */) {
		return -1;
		} else if (rightEntry[TYPE] === 2 /* STATIC */) {
		return 1;
		}
		}
		const leftIsSigner = isSignerRole(leftEntry.role);
		if (leftIsSigner !== isSignerRole(rightEntry.role)) {
		return leftIsSigner ? -1 : 1;
		}
		const leftIsWritable = isWritableRole(leftEntry.role);
		if (leftIsWritable !== isWritableRole(rightEntry.role)) {
		return leftIsWritable ? -1 : 1;
		}
		addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator());
		if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE / && rightEntry[TYPE] === 1 / LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
		return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
		} else {
		return addressComparator(leftAddress, rightAddress);
		}
		}).map(([address, addressMeta]) => ({
		address,
		...addressMeta
		}));
		return orderedAccounts;
		}

		// src/compile-address-table-lookups.ts
		function getCompiledAddressTableLookups(orderedAccounts) {
		var _a;
		const index = {};
		for (const account of orderedAccounts) {
		if (!("lookupTableAddress" in account)) {
		continue;
		}
		const entry = index[_a = account.lookupTableAddress] \|\| (index[_a] = {
		readableIndices: [],
		writableIndices: []
		});
		if (account.role === AccountRole.WRITABLE) {
		entry.writableIndices.push(account.addressIndex);
		} else {
		entry.readableIndices.push(account.addressIndex);
		}
		}
		return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
		lookupTableAddress,
		...index[lookupTableAddress]
		}));
		}

		// src/compile-header.ts
		function getCompiledMessageHeader(orderedAccounts) {
		let numReadonlyNonSignerAccounts = 0;
		let numReadonlySignerAccounts = 0;
		let numSignerAccounts = 0;
		for (const account of orderedAccounts) {
		if ("lookupTableAddress" in account) {
		break;
		}
		const accountIsWritable = isWritableRole(account.role);
		if (isSignerRole(account.role)) {
		numSignerAccounts++;
		if (!accountIsWritable) {
		numReadonlySignerAccounts++;
		}
		} else if (!accountIsWritable) {
		numReadonlyNonSignerAccounts++;
		}
		}
		return {
		numReadonlyNonSignerAccounts,
		numReadonlySignerAccounts,
		numSignerAccounts
		};
		}

		// src/compile-instructions.ts
		function getAccountIndex(orderedAccounts) {
		const out = {};
		for (const [index, account] of orderedAccounts.entries()) {
		out[account.address] = index;
		}
		return out;
		}
		function getCompiledInstructions(instructions, orderedAccounts) {
		const accountIndex = getAccountIndex(orderedAccounts);
		return instructions.map(({ accounts, data, programAddress }) => {
		return {
		programAddressIndex: accountIndex[programAddress],
		...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
		...data ? { data } : null
		};
		});
		}

		// src/compile-lifetime-token.ts
		function getCompiledLifetimeToken(lifetimeConstraint) {
		if ("nonce" in lifetimeConstraint) {
		return lifetimeConstraint.nonce;
		}
		return lifetimeConstraint.blockhash;
		}

		// src/compile-static-accounts.ts
		function getCompiledStaticAccounts(orderedAccounts) {
		const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
		const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
		return orderedStaticAccounts.map(({ address }) => address);
		}

		// src/message.ts
		function compileMessage(transaction) {
		const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
		const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
		return {
		...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
		header: getCompiledMessageHeader(orderedAccounts),
		instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
		lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
		staticAccounts: getCompiledStaticAccounts(orderedAccounts),
		version: transaction.version
		};
		}

		// src/serializers/address-table-lookup.ts
		function getAddressTableLookupCodec() {
		return struct(
		[
		[
		"lookupTableAddress",
		getBase58EncodedAddressCodec(
		{
		description: "The address of the address lookup table account from which instruction addresses should be looked up"
		}
		)
		],
		[
		"writableIndices",
		array(u8(), {
		...{
		description: "The indices of the accounts in the lookup table that should be loaded as writeable"
		} ,
		size: shortU16()
		})
		],
		[
		"readableIndices",
		array(u8(), {
		...{
		description: "The indices of the accounts in the lookup table that should be loaded as read-only"
		} ,
		size: shortU16()
		})
		]
		],
		{
		description: "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it"
		}
		);
		}

		// src/serializers/header.ts
		function getMessageHeaderCodec() {
		return struct(
		[
		[
		"numSignerAccounts",
		u8(
		{
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
		}
		)
		],
		[
		"numReadonlySignerAccounts",
		u8(
		{
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
		}
		)
		],
		[
		"numReadonlyNonSignerAccounts",
		u8(
		{
		description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
		}
		)
		]
		],
		{
		description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
		}
		);
		}

		// src/serializers/instruction.ts
		function getInstructionCodec() {
		return mapSerializer(
		struct([
		[
		"programAddressIndex",
		u8(
		{
		description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
		}
		)
		],
		[
		"addressIndices",
		array(
		u8({
		description: "The index of an account, according to the well-ordered accounts list for this transaction"
		}),
		{
		description: "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" ,
		size: shortU16()
		}
		)
		],
		[
		"data",
		bytes({
		description: "An optional buffer of data passed to the instruction" ,
		size: shortU16()
		})
		]
		]),
		(value) => {
		if (value.addressIndices !== void 0 && value.data !== void 0) {
		return value;
		}
		return {
		...value,
		addressIndices: value.addressIndices ?? [],
		data: value.data ?? new Uint8Array(0)
		};
		},
		(value) => {
		if (value.addressIndices.length && value.data.byteLength) {
		return value;
		}
		const { addressIndices, data, ...rest } = value;
		return {
		...rest,
		...addressIndices.length ? { addressIndices } : null,
		...data.byteLength ? { data } : null
		};
		}
		);
		}

		// src/serializers/unimplemented.ts
		function getError(type, name) {
		const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
		return new Error(
		`No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
		);
		}
		function getUnimplementedDecoder(name) {
		return () => {
		throw getError("decoder", name);
		};
		}

		// src/serializers/transaction-version.ts
		var VERSION_FLAG_MASK = 128;
		var BASE_CONFIG = {
		description: "A single byte that encodes the version of the transaction" ,
		fixedSize: null,
		maxSize: 1
		};
		function deserialize(bytes2, offset = 0) {
		const firstByte = bytes2[offset];
		if ((firstByte & VERSION_FLAG_MASK) === 0) {
		return ["legacy", offset];
		} else {
		const version = firstByte ^ VERSION_FLAG_MASK;
		return [version, offset + 1];
		}
		}
		function serialize(value) {
		if (value === "legacy") {
		return new Uint8Array();
		}
		if (value < 0 \|\| value > 127) {
		throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
		}
		return new Uint8Array([value \| VERSION_FLAG_MASK]);
		}
		function getTransactionVersionCodec() {
		return {
		...BASE_CONFIG,
		deserialize,
		serialize
		};
		}

		// src/serializers/message.ts
		var BASE_CONFIG2 = {
		description: "The wire format of a Solana transaction message" ,
		fixedSize: null,
		maxSize: null
		};
		function serialize2(compiledMessage) {
		if (compiledMessage.version === "legacy") {
		return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
		} else {
		return mapSerializer(
		struct([
		...getPreludeStructSerializerTuple(),
		["addressTableLookups", getAddressTableLookupsSerializer()]
		]),
		(value) => {
		if (value.version === "legacy") {
		return value;
		}
		return {
		...value,
		addressTableLookups: value.addressTableLookups ?? []
		};
		}
		).serialize(compiledMessage);
		}
		}
		function getPreludeStructSerializerTuple() {
		return [
		["version", getTransactionVersionCodec()],
		["header", getMessageHeaderCodec()],
		[
		"staticAccounts",
		array(getBase58EncodedAddressCodec(), {
		description: "A compact-array of static account addresses belonging to this transaction" ,
		size: shortU16()
		})
		],
		[
		"lifetimeToken",
		string({
		description: "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" ,
		encoding: base58,
		size: 32
		})
		],
		[
		"instructions",
		array(getInstructionCodec(), {
		description: "A compact-array of instructions belonging to this transaction" ,
		size: shortU16()
		})
		]
		];
		}
		function getAddressTableLookupsSerializer() {
		return array(getAddressTableLookupCodec(), {
		...{ description: "A compact array of address table lookups belonging to this transaction" } ,
		size: shortU16()
		});
		}
		function getCompiledMessageEncoder() {
		return {
		...BASE_CONFIG2,
		deserialize: getUnimplementedDecoder("CompiledMessage"),
		serialize: serialize2
		};
		}

		// src/signatures.ts
		async function getCompiledMessageSignature(message, secretKey) {
		const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
		const signature = await signBytes(secretKey, wireMessageBytes);
		return signature;
		}
		async function signTransaction(keyPair, transaction) {
		const compiledMessage = compileMessage(transaction);
		const [signerPublicKey, signature] = await Promise.all([
		getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
		getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
		]);
		const nextSignatures = {
		..."signatures" in transaction ? transaction.signatures : null,
		...{ [signerPublicKey]: signature }
		};
		const out = {
		...transaction,
		signatures: nextSignatures
		};
		Object.freeze(out);
		return out;
		}

		exports.appendTransactionInstruction = appendTransactionInstruction;
		@@ -83,2 +1184,3 @@ exports.createTransaction = createTransaction;
		exports.setTransactionFeePayer = setTransactionFeePayer;
		exports.signTransaction = signTransaction;

		@@ -85,0 +1187,0 @@ return exports;

558

dist/index.native.js

		@@ -0,1 +1,7 @@
		import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
		import { struct, mapSerializer, array, shortU16, string, base58, u8, bytes } from '@metaplex-foundation/umi-serializers';

		// ../build-scripts/env-shim.ts
		var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();

		// src/create-transaction.ts
		@@ -73,4 +79,554 @@ function createTransaction({

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
		// ../instructions/dist/index.browser.js
		var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
		AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
		3] = "WRITABLE_SIGNER";
		AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
		2] = "READONLY_SIGNER";
		AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
		1] = "WRITABLE";
		AccountRole2[AccountRole2["READONLY"] = /* 0 */
		0] = "READONLY";
		return AccountRole2;
		})(AccountRole \|\| {});
		var IS_WRITABLE_BITMASK = 1;
		function isSignerRole(role) {
		return role >= 2;
		}
		function isWritableRole(role) {
		return (role & IS_WRITABLE_BITMASK) !== 0;
		}
		function mergeRoles(roleA, roleB) {
		return roleA \| roleB;
		}
		function upsert(addressMap, address, update) {
		addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
		}
		var TYPE = Symbol("AddressMapTypeProperty");
		function getAddressMapFromInstructions(feePayer, instructions) {
		const addressMap = {
		[feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
		};
		const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
		for (const instruction of instructions) {
		upsert(addressMap, instruction.programAddress, (entry) => {
		addressesOfInvokedPrograms.add(instruction.programAddress);
		if (TYPE in entry) {
		if (isWritableRole(entry.role)) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
		);
		default:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		}
		if (entry[TYPE] === 2 /* STATIC */) {
		return entry;
		}
		}
		return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
		});
		let addressComparator;
		if (!instruction.accounts) {
		continue;
		}
		for (const account of instruction.accounts) {
		upsert(addressMap, account.address, (entry) => {
		const {
		// eslint-disable-next-line @typescript-eslint/no-unused-vars
		address: _,
		...accountMeta
		} = account;
		if (TYPE in entry) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		return entry;
		case 1 /* LOOKUP_TABLE */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if ("lookupTableAddress" in accountMeta) {
		const shouldReplaceEntry = (
		// Consider using the new LOOKUP_TABLE if its address is different...
		entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
		(addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator()))(
		accountMeta.lookupTableAddress,
		entry.lookupTableAddress
		) < 0
		);
		if (shouldReplaceEntry) {
		return {
		[TYPE]: 1 /* LOOKUP_TABLE */,
		...accountMeta,
		role: nextRole
		};
		}
		} else if (isSignerRole(accountMeta.role)) {
		return {
		[TYPE]: 2 /* STATIC */,
		role: nextRole
		};
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		case 2 /* STATIC */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if (
		// Check to see if this address represents a program that is invoked
		// in this transaction.
		addressesOfInvokedPrograms.has(account.address)
		) {
		if (isWritableRole(accountMeta.role)) {
		throw new Error(
		`This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		} else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
		// long as they are not require to sign the transaction.
		!isSignerRole(entry.role)) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */,
		role: nextRole
		};
		} else {
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		}
		}
		}
		if ("lookupTableAddress" in accountMeta) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */
		};
		} else {
		return {
		...accountMeta,
		[TYPE]: 2 /* STATIC */
		};
		}
		});
		}
		}
		return addressMap;
		}
		function getOrderedAccountsFromAddressMap(addressMap) {
		let addressComparator;
		const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
		if (leftEntry[TYPE] !== rightEntry[TYPE]) {
		if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
		return -1;
		} else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
		return 1;
		} else if (leftEntry[TYPE] === 2 /* STATIC */) {
		return -1;
		} else if (rightEntry[TYPE] === 2 /* STATIC */) {
		return 1;
		}
		}
		const leftIsSigner = isSignerRole(leftEntry.role);
		if (leftIsSigner !== isSignerRole(rightEntry.role)) {
		return leftIsSigner ? -1 : 1;
		}
		const leftIsWritable = isWritableRole(leftEntry.role);
		if (leftIsWritable !== isWritableRole(rightEntry.role)) {
		return leftIsWritable ? -1 : 1;
		}
		addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator());
		if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE / && rightEntry[TYPE] === 1 / LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
		return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
		} else {
		return addressComparator(leftAddress, rightAddress);
		}
		}).map(([address, addressMeta]) => ({
		address,
		...addressMeta
		}));
		return orderedAccounts;
		}
		function getCompiledAddressTableLookups(orderedAccounts) {
		var _a;
		const index = {};
		for (const account of orderedAccounts) {
		if (!("lookupTableAddress" in account)) {
		continue;
		}
		const entry = index[_a = account.lookupTableAddress] \|\| (index[_a] = {
		readableIndices: [],
		writableIndices: []
		});
		if (account.role === AccountRole.WRITABLE) {
		entry.writableIndices.push(account.addressIndex);
		} else {
		entry.readableIndices.push(account.addressIndex);
		}
		}
		return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
		lookupTableAddress,
		...index[lookupTableAddress]
		}));
		}

		// src/compile-header.ts
		function getCompiledMessageHeader(orderedAccounts) {
		let numReadonlyNonSignerAccounts = 0;
		let numReadonlySignerAccounts = 0;
		let numSignerAccounts = 0;
		for (const account of orderedAccounts) {
		if ("lookupTableAddress" in account) {
		break;
		}
		const accountIsWritable = isWritableRole(account.role);
		if (isSignerRole(account.role)) {
		numSignerAccounts++;
		if (!accountIsWritable) {
		numReadonlySignerAccounts++;
		}
		} else if (!accountIsWritable) {
		numReadonlyNonSignerAccounts++;
		}
		}
		return {
		numReadonlyNonSignerAccounts,
		numReadonlySignerAccounts,
		numSignerAccounts
		};
		}

		// src/compile-instructions.ts
		function getAccountIndex(orderedAccounts) {
		const out = {};
		for (const [index, account] of orderedAccounts.entries()) {
		out[account.address] = index;
		}
		return out;
		}
		function getCompiledInstructions(instructions, orderedAccounts) {
		const accountIndex = getAccountIndex(orderedAccounts);
		return instructions.map(({ accounts, data, programAddress }) => {
		return {
		programAddressIndex: accountIndex[programAddress],
		...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
		...data ? { data } : null
		};
		});
		}

		// src/compile-lifetime-token.ts
		function getCompiledLifetimeToken(lifetimeConstraint) {
		if ("nonce" in lifetimeConstraint) {
		return lifetimeConstraint.nonce;
		}
		return lifetimeConstraint.blockhash;
		}

		// src/compile-static-accounts.ts
		function getCompiledStaticAccounts(orderedAccounts) {
		const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
		const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
		return orderedStaticAccounts.map(({ address }) => address);
		}

		// src/message.ts
		function compileMessage(transaction) {
		const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
		const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
		return {
		...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
		header: getCompiledMessageHeader(orderedAccounts),
		instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
		lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
		staticAccounts: getCompiledStaticAccounts(orderedAccounts),
		version: transaction.version
		};
		}
		function getAddressTableLookupCodec() {
		return struct(
		[
		[
		"lookupTableAddress",
		getBase58EncodedAddressCodec(
		__DEV__ ? {
		description: "The address of the address lookup table account from which instruction addresses should be looked up"
		} : void 0
		)
		],
		[
		"writableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as writeable"
		} : null,
		size: shortU16()
		})
		],
		[
		"readableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as read-only"
		} : void 0,
		size: shortU16()
		})
		]
		],
		__DEV__ ? {
		description: "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it"
		} : void 0
		);
		}
		function getMessageHeaderCodec() {
		return struct(
		[
		[
		"numSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
		} : void 0
		)
		],
		[
		"numReadonlySignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
		} : void 0
		)
		],
		[
		"numReadonlyNonSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
		} : void 0
		)
		]
		],
		__DEV__ ? {
		description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
		} : void 0
		);
		}
		function getInstructionCodec() {
		return mapSerializer(
		struct([
		[
		"programAddressIndex",
		u8(
		__DEV__ ? {
		description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
		} : void 0
		)
		],
		[
		"addressIndices",
		array(
		u8({
		description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
		}),
		{
		description: __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "",
		size: shortU16()
		}
		)
		],
		[
		"data",
		bytes({
		description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
		size: shortU16()
		})
		]
		]),
		(value) => {
		if (value.addressIndices !== void 0 && value.data !== void 0) {
		return value;
		}
		return {
		...value,
		addressIndices: value.addressIndices ?? [],
		data: value.data ?? new Uint8Array(0)
		};
		},
		(value) => {
		if (value.addressIndices.length && value.data.byteLength) {
		return value;
		}
		const { addressIndices, data, ...rest } = value;
		return {
		...rest,
		...addressIndices.length ? { addressIndices } : null,
		...data.byteLength ? { data } : null
		};
		}
		);
		}

		// src/serializers/unimplemented.ts
		function getError(type, name) {
		const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
		return new Error(
		`No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
		);
		}
		function getUnimplementedDecoder(name) {
		return () => {
		throw getError("decoder", name);
		};
		}

		// src/serializers/transaction-version.ts
		var VERSION_FLAG_MASK = 128;
		var BASE_CONFIG = {
		description: __DEV__ ? "A single byte that encodes the version of the transaction" : "",
		fixedSize: null,
		maxSize: 1
		};
		function deserialize(bytes2, offset = 0) {
		const firstByte = bytes2[offset];
		if ((firstByte & VERSION_FLAG_MASK) === 0) {
		return ["legacy", offset];
		} else {
		const version = firstByte ^ VERSION_FLAG_MASK;
		return [version, offset + 1];
		}
		}
		function serialize(value) {
		if (value === "legacy") {
		return new Uint8Array();
		}
		if (value < 0 \|\| value > 127) {
		throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
		}
		return new Uint8Array([value \| VERSION_FLAG_MASK]);
		}
		function getTransactionVersionCodec() {
		return {
		...BASE_CONFIG,
		deserialize,
		serialize
		};
		}

		// src/serializers/message.ts
		var BASE_CONFIG2 = {
		description: __DEV__ ? "The wire format of a Solana transaction message" : "",
		fixedSize: null,
		maxSize: null
		};
		function serialize2(compiledMessage) {
		if (compiledMessage.version === "legacy") {
		return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
		} else {
		return mapSerializer(
		struct([
		...getPreludeStructSerializerTuple(),
		["addressTableLookups", getAddressTableLookupsSerializer()]
		]),
		(value) => {
		if (value.version === "legacy") {
		return value;
		}
		return {
		...value,
		addressTableLookups: value.addressTableLookups ?? []
		};
		}
		).serialize(compiledMessage);
		}
		}
		function getPreludeStructSerializerTuple() {
		return [
		["version", getTransactionVersionCodec()],
		["header", getMessageHeaderCodec()],
		[
		"staticAccounts",
		array(getBase58EncodedAddressCodec(), {
		description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
		size: shortU16()
		})
		],
		[
		"lifetimeToken",
		string({
		description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
		encoding: base58,
		size: 32
		})
		],
		[
		"instructions",
		array(getInstructionCodec(), {
		description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
		size: shortU16()
		})
		]
		];
		}
		function getAddressTableLookupsSerializer() {
		return array(getAddressTableLookupCodec(), {
		...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
		size: shortU16()
		});
		}
		function getCompiledMessageEncoder() {
		return {
		...BASE_CONFIG2,
		deserialize: getUnimplementedDecoder("CompiledMessage"),
		serialize: serialize2
		};
		}

		// src/signatures.ts
		async function getCompiledMessageSignature(message, secretKey) {
		const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
		const signature = await signBytes(secretKey, wireMessageBytes);
		return signature;
		}
		async function signTransaction(keyPair, transaction) {
		const compiledMessage = compileMessage(transaction);
		const [signerPublicKey, signature] = await Promise.all([
		getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
		getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
		]);
		const nextSignatures = {
		..."signatures" in transaction ? transaction.signatures : null,
		...{ [signerPublicKey]: signature }
		};
		const out = {
		...transaction,
		signatures: nextSignatures
		};
		Object.freeze(out);
		return out;
		}

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.native.js.map

560

dist/index.node.js

		@@ -0,1 +1,7 @@
		import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
		import { struct, mapSerializer, array, shortU16, string, base58, u8, bytes } from '@metaplex-foundation/umi-serializers';

		// ../build-scripts/env-shim.ts
		var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();

		// src/create-transaction.ts
		@@ -73,2 +79,554 @@ function createTransaction({

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
		// ../instructions/dist/index.node.js
		var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
		AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
		3] = "WRITABLE_SIGNER";
		AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
		2] = "READONLY_SIGNER";
		AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
		1] = "WRITABLE";
		AccountRole2[AccountRole2["READONLY"] = /* 0 */
		0] = "READONLY";
		return AccountRole2;
		})(AccountRole \|\| {});
		var IS_WRITABLE_BITMASK = 1;
		function isSignerRole(role) {
		return role >= 2;
		}
		function isWritableRole(role) {
		return (role & IS_WRITABLE_BITMASK) !== 0;
		}
		function mergeRoles(roleA, roleB) {
		return roleA \| roleB;
		}
		function upsert(addressMap, address, update) {
		addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
		}
		var TYPE = Symbol("AddressMapTypeProperty");
		function getAddressMapFromInstructions(feePayer, instructions) {
		const addressMap = {
		[feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
		};
		const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
		for (const instruction of instructions) {
		upsert(addressMap, instruction.programAddress, (entry) => {
		addressesOfInvokedPrograms.add(instruction.programAddress);
		if (TYPE in entry) {
		if (isWritableRole(entry.role)) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
		);
		default:
		throw new Error(
		`This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		}
		if (entry[TYPE] === 2 /* STATIC */) {
		return entry;
		}
		}
		return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
		});
		let addressComparator;
		if (!instruction.accounts) {
		continue;
		}
		for (const account of instruction.accounts) {
		upsert(addressMap, account.address, (entry) => {
		const {
		// eslint-disable-next-line @typescript-eslint/no-unused-vars
		address: _,
		...accountMeta
		} = account;
		if (TYPE in entry) {
		switch (entry[TYPE]) {
		case 0 /* FEE_PAYER */:
		return entry;
		case 1 /* LOOKUP_TABLE */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if ("lookupTableAddress" in accountMeta) {
		const shouldReplaceEntry = (
		// Consider using the new LOOKUP_TABLE if its address is different...
		entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
		(addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator()))(
		accountMeta.lookupTableAddress,
		entry.lookupTableAddress
		) < 0
		);
		if (shouldReplaceEntry) {
		return {
		[TYPE]: 1 /* LOOKUP_TABLE */,
		...accountMeta,
		role: nextRole
		};
		}
		} else if (isSignerRole(accountMeta.role)) {
		return {
		[TYPE]: 2 /* STATIC */,
		role: nextRole
		};
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		case 2 /* STATIC */: {
		const nextRole = mergeRoles(entry.role, accountMeta.role);
		if (
		// Check to see if this address represents a program that is invoked
		// in this transaction.
		addressesOfInvokedPrograms.has(account.address)
		) {
		if (isWritableRole(accountMeta.role)) {
		throw new Error(
		`This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
		);
		}
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		} else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
		// long as they are not require to sign the transaction.
		!isSignerRole(entry.role)) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */,
		role: nextRole
		};
		} else {
		if (entry.role !== nextRole) {
		return {
		...entry,
		role: nextRole
		};
		} else {
		return entry;
		}
		}
		}
		}
		}
		if ("lookupTableAddress" in accountMeta) {
		return {
		...accountMeta,
		[TYPE]: 1 /* LOOKUP_TABLE */
		};
		} else {
		return {
		...accountMeta,
		[TYPE]: 2 /* STATIC */
		};
		}
		});
		}
		}
		return addressMap;
		}
		function getOrderedAccountsFromAddressMap(addressMap) {
		let addressComparator;
		const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
		if (leftEntry[TYPE] !== rightEntry[TYPE]) {
		if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
		return -1;
		} else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
		return 1;
		} else if (leftEntry[TYPE] === 2 /* STATIC */) {
		return -1;
		} else if (rightEntry[TYPE] === 2 /* STATIC */) {
		return 1;
		}
		}
		const leftIsSigner = isSignerRole(leftEntry.role);
		if (leftIsSigner !== isSignerRole(rightEntry.role)) {
		return leftIsSigner ? -1 : 1;
		}
		const leftIsWritable = isWritableRole(leftEntry.role);
		if (leftIsWritable !== isWritableRole(rightEntry.role)) {
		return leftIsWritable ? -1 : 1;
		}
		addressComparator \|\| (addressComparator = getBase58EncodedAddressComparator());
		if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE / && rightEntry[TYPE] === 1 / LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
		return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
		} else {
		return addressComparator(leftAddress, rightAddress);
		}
		}).map(([address, addressMeta]) => ({
		address,
		...addressMeta
		}));
		return orderedAccounts;
		}
		function getCompiledAddressTableLookups(orderedAccounts) {
		var _a;
		const index = {};
		for (const account of orderedAccounts) {
		if (!("lookupTableAddress" in account)) {
		continue;
		}
		const entry = index[_a = account.lookupTableAddress] \|\| (index[_a] = {
		readableIndices: [],
		writableIndices: []
		});
		if (account.role === AccountRole.WRITABLE) {
		entry.writableIndices.push(account.addressIndex);
		} else {
		entry.readableIndices.push(account.addressIndex);
		}
		}
		return Object.keys(index).sort(getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
		lookupTableAddress,
		...index[lookupTableAddress]
		}));
		}

		// src/compile-header.ts
		function getCompiledMessageHeader(orderedAccounts) {
		let numReadonlyNonSignerAccounts = 0;
		let numReadonlySignerAccounts = 0;
		let numSignerAccounts = 0;
		for (const account of orderedAccounts) {
		if ("lookupTableAddress" in account) {
		break;
		}
		const accountIsWritable = isWritableRole(account.role);
		if (isSignerRole(account.role)) {
		numSignerAccounts++;
		if (!accountIsWritable) {
		numReadonlySignerAccounts++;
		}
		} else if (!accountIsWritable) {
		numReadonlyNonSignerAccounts++;
		}
		}
		return {
		numReadonlyNonSignerAccounts,
		numReadonlySignerAccounts,
		numSignerAccounts
		};
		}

		// src/compile-instructions.ts
		function getAccountIndex(orderedAccounts) {
		const out = {};
		for (const [index, account] of orderedAccounts.entries()) {
		out[account.address] = index;
		}
		return out;
		}
		function getCompiledInstructions(instructions, orderedAccounts) {
		const accountIndex = getAccountIndex(orderedAccounts);
		return instructions.map(({ accounts, data, programAddress }) => {
		return {
		programAddressIndex: accountIndex[programAddress],
		...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
		...data ? { data } : null
		};
		});
		}

		// src/compile-lifetime-token.ts
		function getCompiledLifetimeToken(lifetimeConstraint) {
		if ("nonce" in lifetimeConstraint) {
		return lifetimeConstraint.nonce;
		}
		return lifetimeConstraint.blockhash;
		}

		// src/compile-static-accounts.ts
		function getCompiledStaticAccounts(orderedAccounts) {
		const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
		const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
		return orderedStaticAccounts.map(({ address }) => address);
		}

		// src/message.ts
		function compileMessage(transaction) {
		const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
		const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
		return {
		...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
		header: getCompiledMessageHeader(orderedAccounts),
		instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
		lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
		staticAccounts: getCompiledStaticAccounts(orderedAccounts),
		version: transaction.version
		};
		}
		function getAddressTableLookupCodec() {
		return struct(
		[
		[
		"lookupTableAddress",
		getBase58EncodedAddressCodec(
		__DEV__ ? {
		description: "The address of the address lookup table account from which instruction addresses should be looked up"
		} : void 0
		)
		],
		[
		"writableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as writeable"
		} : null,
		size: shortU16()
		})
		],
		[
		"readableIndices",
		array(u8(), {
		...__DEV__ ? {
		description: "The indices of the accounts in the lookup table that should be loaded as read-only"
		} : void 0,
		size: shortU16()
		})
		]
		],
		__DEV__ ? {
		description: "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it"
		} : void 0
		);
		}
		function getMessageHeaderCodec() {
		return struct(
		[
		[
		"numSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
		} : void 0
		)
		],
		[
		"numReadonlySignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable"
		} : void 0
		)
		],
		[
		"numReadonlyNonSignerAccounts",
		u8(
		__DEV__ ? {
		description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
		} : void 0
		)
		]
		],
		__DEV__ ? {
		description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
		} : void 0
		);
		}
		function getInstructionCodec() {
		return mapSerializer(
		struct([
		[
		"programAddressIndex",
		u8(
		__DEV__ ? {
		description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
		} : void 0
		)
		],
		[
		"addressIndices",
		array(
		u8({
		description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
		}),
		{
		description: __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "",
		size: shortU16()
		}
		)
		],
		[
		"data",
		bytes({
		description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
		size: shortU16()
		})
		]
		]),
		(value) => {
		if (value.addressIndices !== void 0 && value.data !== void 0) {
		return value;
		}
		return {
		...value,
		addressIndices: value.addressIndices ?? [],
		data: value.data ?? new Uint8Array(0)
		};
		},
		(value) => {
		if (value.addressIndices.length && value.data.byteLength) {
		return value;
		}
		const { addressIndices, data, ...rest } = value;
		return {
		...rest,
		...addressIndices.length ? { addressIndices } : null,
		...data.byteLength ? { data } : null
		};
		}
		);
		}

		// src/serializers/unimplemented.ts
		function getError(type, name) {
		const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
		return new Error(
		`No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
		);
		}
		function getUnimplementedDecoder(name) {
		return () => {
		throw getError("decoder", name);
		};
		}

		// src/serializers/transaction-version.ts
		var VERSION_FLAG_MASK = 128;
		var BASE_CONFIG = {
		description: __DEV__ ? "A single byte that encodes the version of the transaction" : "",
		fixedSize: null,
		maxSize: 1
		};
		function deserialize(bytes2, offset = 0) {
		const firstByte = bytes2[offset];
		if ((firstByte & VERSION_FLAG_MASK) === 0) {
		return ["legacy", offset];
		} else {
		const version = firstByte ^ VERSION_FLAG_MASK;
		return [version, offset + 1];
		}
		}
		function serialize(value) {
		if (value === "legacy") {
		return new Uint8Array();
		}
		if (value < 0 \|\| value > 127) {
		throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
		}
		return new Uint8Array([value \| VERSION_FLAG_MASK]);
		}
		function getTransactionVersionCodec() {
		return {
		...BASE_CONFIG,
		deserialize,
		serialize
		};
		}

		// src/serializers/message.ts
		var BASE_CONFIG2 = {
		description: __DEV__ ? "The wire format of a Solana transaction message" : "",
		fixedSize: null,
		maxSize: null
		};
		function serialize2(compiledMessage) {
		if (compiledMessage.version === "legacy") {
		return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
		} else {
		return mapSerializer(
		struct([
		...getPreludeStructSerializerTuple(),
		["addressTableLookups", getAddressTableLookupsSerializer()]
		]),
		(value) => {
		if (value.version === "legacy") {
		return value;
		}
		return {
		...value,
		addressTableLookups: value.addressTableLookups ?? []
		};
		}
		).serialize(compiledMessage);
		}
		}
		function getPreludeStructSerializerTuple() {
		return [
		["version", getTransactionVersionCodec()],
		["header", getMessageHeaderCodec()],
		[
		"staticAccounts",
		array(getBase58EncodedAddressCodec(), {
		description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
		size: shortU16()
		})
		],
		[
		"lifetimeToken",
		string({
		description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
		encoding: base58,
		size: 32
		})
		],
		[
		"instructions",
		array(getInstructionCodec(), {
		description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
		size: shortU16()
		})
		]
		];
		}
		function getAddressTableLookupsSerializer() {
		return array(getAddressTableLookupCodec(), {
		...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
		size: shortU16()
		});
		}
		function getCompiledMessageEncoder() {
		return {
		...BASE_CONFIG2,
		deserialize: getUnimplementedDecoder("CompiledMessage"),
		serialize: serialize2
		};
		}

		// src/signatures.ts
		async function getCompiledMessageSignature(message, secretKey) {
		const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
		const signature = await signBytes(secretKey, wireMessageBytes);
		return signature;
		}
		async function signTransaction(keyPair, transaction) {
		const compiledMessage = compileMessage(transaction);
		const [signerPublicKey, signature] = await Promise.all([
		getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
		getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
		]);
		const nextSignatures = {
		..."signatures" in transaction ? transaction.signatures : null,
		...{ [signerPublicKey]: signature }
		};
		const out = {
		...transaction,
		signatures: nextSignatures
		};
		Object.freeze(out);
		return out;
		}

		export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
		//# sourceMappingURL=out.js.map
		//# sourceMappingURL=index.node.js.map

dist/index.production.min.js

		@@ -5,8 +5,9 @@ this.globalThis = this.globalThis \|\| {};

		function T({version:r}){let n={instructions:[],version:r};return Object.freeze(n),n}function d(r,n){if("feePayer"in n&&r===n.feePayer)return n;let t;if("signatures"in n){let{signatures:e,...s}=n;t={...s,feePayer:r};}else t={...n,feePayer:r};return Object.freeze(t),t}function i(r,n){let t;if("signatures"in r){let{signatures:e,...s}=r;t={...s,instructions:n};}else t={...r,instructions:n};return t}function m(r,n){let t=[...n.instructions,r],e=i(n,t);return Object.freeze(e),e}function x(r,n){let t=[r,...n.instructions],e=i(n,t);return Object.freeze(e),e}
		var Ae=Object.defineProperty;var Ee=(e,r,t)=>r in e?Ae(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var f=(e,r,t)=>(Ee(e,typeof r!="symbol"?r+"":r,t),t);function $e({version:e}){let r={instructions:[],version:e};return Object.freeze(r),r}function Fe(e,r){if("feePayer"in r&&e===r.feePayer)return r;let t;if("signatures"in r){let{signatures:n,...o}=r;t={...o,feePayer:e};}else t={...r,feePayer:e};return Object.freeze(t),t}function q(e,r){let t;if("signatures"in e){let{signatures:n,...o}=e;t={...o,instructions:r};}else t={...e,instructions:r};return t}function je(e,r){let t=[...r.instructions,e],n=q(r,t);return Object.freeze(n),n}function Ge(e,r){let t=[e,...r.instructions],n=q(r,t);return Object.freeze(n),n}var A=e=>{let r=e.reduce((o,s)=>o+s.length,0),t=new Uint8Array(r),n=0;return e.forEach(o=>{t.set(o,n),n+=o.length;}),t},X=(e,r)=>{if(e.length>=r)return e;let t=new Uint8Array(r).fill(0);return t.set(e),t},P=(e,r)=>X(e.slice(0,r),r);var E=class extends Error{constructor(t){super(`Serializer [${t}] cannot deserialize empty buffers.`);f(this,"name","DeserializingEmptyBufferError");}},g=class extends Error{constructor(t,n,o){super(`Serializer [${t}] expected ${n} bytes, got ${o}.`);f(this,"name","NotEnoughBytesError");}},x=class extends Error{constructor(t){t??(t="Expected a fixed-size serializer, got a variable-size one.");super(t);f(this,"name","ExpectedFixedSizeSerializerError");}};function C(e,r,t){return {description:t??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r,serialize:n=>P(e.serialize(n),r),deserialize:(n,o=0)=>{if(n=n.slice(o,o+r),n.length<r)throw new g("fixSerializer",r,n.length);e.fixedSize!==null&&(n=P(n,e.fixedSize));let[s]=e.deserialize(n,0);return [s,o+r]}}}function B(e,r,t){return {description:e.description,fixedSize:e.fixedSize,maxSize:e.maxSize,serialize:n=>e.serialize(r(n)),deserialize:(n,o=0)=>{let[s,i]=e.deserialize(n,o);return t?[t(s,n,o),i]:[s,i]}}}var v=class extends Error{constructor(t,n,o){let s=`Expected a string of base ${n}, got [${t}].`;super(s);f(this,"name","InvalidBaseStringError");this.cause=o;}};var Z=e=>{let r=e.length,t=BigInt(r);return {description:`base${r}`,fixedSize:null,maxSize:null,serialize(n){if(!n.match(new RegExp(`^[${e}]$`)))throw new v(n,r);if(n==="")return new Uint8Array;let o=[...n],s=o.findIndex(m=>m!==e[0]);s=s===-1?o.length:s;let i=Array(s).fill(0);if(s===o.length)return Uint8Array.from(i);let c=o.slice(s),l=0n,d=1n;for(let m=c.length-1;m>=0;m-=1)l+=dBigInt(e.indexOf(c[m])),d=t;let u=[];for(;l>0n;)u.unshift(Number(l%256n)),l/=256n;return Uint8Array.from(i.concat(u))},deserialize(n,o=0){if(n.length===0)return ["",0];let s=n.slice(o),i=s.findIndex(u=>u!==0);i=i===-1?s.length:i;let c=e[0].repeat(i);if(i===s.length)return [c,n.length];let l=s.slice(i).reduce((u,m)=>u256n+BigInt(m),0n),d=[];for(;l>0n;)d.unshift(e[Number(l%t)]),l/=t;return [c+d.join(""),n.length]}}};var k=Z("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");var J=e=>e.replace(/\u0000/g,"");var F={description:"utf8",fixedSize:null,maxSize:null,serialize(e){return new TextEncoder().encode(e)},deserialize(e,r=0){let t=new TextDecoder().decode(e.slice(r));return [J(t),e.length]}};var D;(function(e){e.Little="le",e.Big="be";})(D\|\|(D={}));var N=class extends RangeError{constructor(t,n,o,s){super(`Serializer [${t}] expected number to be between ${n} and ${o}, got ${s}.`);f(this,"name","NumberOutOfRangeError");}};function V(e){let r,t=e.name;return e.size>1&&(r=!("endian"in e.options)\|\|e.options.endian===D.Little,t+=r?"(le)":"(be)"),{description:e.options.description??t,fixedSize:e.size,maxSize:e.size,serialize(n){e.range&&K(e.name,e.range[0],e.range[1],n);let o=new ArrayBuffer(e.size);return e.set(new DataView(o),n,r),new Uint8Array(o)},deserialize(n,o=0){let s=n.slice(o,o+e.size);ze("i8",s,e.size);let i=Se(s);return [e.get(i,r),o+e.size]}}}var xe=e=>e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset),Se=e=>new DataView(xe(e)),K=(e,r,t,n)=>{if(n<r\|\|n>t)throw new N(e,r,t,n)},ze=(e,r,t)=>{if(r.length===0)throw new E(e);if(r.length<t)throw new g(e,t,r.length)};var y=(e={})=>V({name:"u8",size:1,range:[0,+"0xff"],set:(r,t)=>r.setUint8(0,Number(t)),get:r=>r.getUint8(0),options:e});var R=(e={})=>V({name:"u32",size:4,range:[0,+"0xffffffff"],set:(r,t,n)=>r.setUint32(0,Number(t),n),get:(r,t)=>r.getUint32(0,t),options:e});var T=(e={})=>({description:e.description??"shortU16",fixedSize:null,maxSize:3,serialize:r=>{K("shortU16",0,65535,r);let t=[0];for(let n=0;;n+=1){let o=r>>n7;if(o===0)break;let s=127&o;t[n]=s,n>0&&(t[n-1]\|=128);}return new Uint8Array(t)},deserialize:(r,t=0)=>{let n=0,o=0;for(;++o;){let s=o-1,i=r[t+s],c=127&i;if(n\|=c<<s7,!(i&128))break}return [n,t+o]}});var $=class extends Error{constructor(t,n,o){super(`Expected [${t}] to have ${n} items, got ${o}.`);f(this,"name","InvalidNumberOfItemsError");}},U=class extends Error{constructor(t,n){super(`The remainder of the buffer (${t} bytes) cannot be split into chunks of ${n} bytes. Serializers of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${t} modulo ${n} should be equal to zero.`);f(this,"name","InvalidArrayLikeRemainderSizeError");}},W=class extends Error{constructor(t){super(`Unrecognized array-like serializer size: ${JSON.stringify(t)}`);f(this,"name","UnrecognizedArrayLikeSerializerSizeError");}};function w(e){return e.reduce((r,t)=>r===null\|\|t===null?null:r+t,0)}function Q(e,r,t,n){if(typeof e=="number")return [e,n];if(typeof e=="object")return e.deserialize(t,n);if(e==="remainder"){let o=w(r);if(o===null)throw new x('Serializers of "remainder" size must have fixed-size items.');let s=t.slice(n).length;if(s%o!==0)throw new U(s,o);return [s/o,n]}throw new W(e)}function _(e){return typeof e=="object"?e.description:`${e}`}function Y(e,r){if(typeof e!="number")return null;if(e===0)return 0;let t=w(r);return t===null?null:t*e}function ee(e,r){return typeof e=="object"?e.serialize(r):new Uint8Array}function h(e,r={}){let t=r.size??R();if(t==="remainder"&&e.fixedSize===null)throw new x('Serializers of "remainder" size must have fixed-size items.');return {description:r.description??`array(${e.description}; ${_(t)})`,fixedSize:Y(t,[e.fixedSize]),maxSize:Y(t,[e.maxSize]),serialize:n=>{if(typeof t=="number"&&n.length!==t)throw new $("array",t,n.length);return A([ee(t,n.length),...n.map(o=>e.serialize(o))])},deserialize:(n,o=0)=>{if(typeof t=="object"&&n.slice(o).length===0)return [[],o];let[s,i]=Q(t,[e.fixedSize],n,o);o=i;let c=[];for(let l=0;l<s;l+=1){let[d,u]=e.deserialize(n,o);c.push(d),o=u;}return [c,o]}}}function j(e={}){let r=e.size??"variable",t=e.description??`bytes(${_(r)})`,n={description:t,fixedSize:null,maxSize:null,serialize:o=>new Uint8Array(o),deserialize:(o,s=0)=>{let i=o.slice(s);return [i,s+i.length]}};return r==="variable"?n:typeof r=="number"?C(n,r,t):{description:t,fixedSize:null,maxSize:null,serialize:o=>{let s=n.serialize(o),i=r.serialize(s.length);return A([i,s])},deserialize:(o,s=0)=>{if(o.slice(s).length===0)throw new E("bytes");let[i,c]=r.deserialize(o,s),l=Number(i);s=c;let d=o.slice(s,s+l);if(d.length<l)throw new g("bytes",l,d.length);let[u,m]=n.deserialize(d);return s+=m,[u,s]}}}function M(e={}){let r=e.size??R(),t=e.encoding??F,n=e.description??`string(${t.description}; ${_(r)})`;return r==="variable"?{...t,description:n}:typeof r=="number"?C(t,r,n):{description:n,fixedSize:null,maxSize:null,serialize:o=>{let s=t.serialize(o),i=r.serialize(s.length);return A([i,s])},deserialize:(o,s=0)=>{if(o.slice(s).length===0)throw new E("string");let[i,c]=r.deserialize(o,s),l=Number(i);s=c;let d=o.slice(s,s+l);if(d.length<l)throw new g("string",l,d.length);let[u,m]=t.deserialize(d);return s+=m,[u,s]}}}function b(e,r={}){let t=e.map(([n,o])=>`${String(n)}: ${o.description}`).join(", ");return {description:r.description??`struct(${t})`,fixedSize:w(e.map(([,n])=>n.fixedSize)),maxSize:w(e.map(([,n])=>n.maxSize)),serialize:n=>{let o=e.map(([s,i])=>i.serialize(n[s]));return A(o)},deserialize:(n,o=0)=>{let s={};return e.forEach(([i,c])=>{let[l,d]=c.deserialize(n,o);o=d,s[i]=l;}),[s,o]}}}function L(e){return M({description:e?.description??(""),encoding:k,size:32})}function O(){return new Intl.Collator("en",{caseFirst:"lower",ignorePunctuation:!1,localeMatcher:"best fit",numeric:!1,sensitivity:"variant",usage:"sort"}).compare}function re(){if(!globalThis.isSecureContext)throw new Error("Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts")}async function we(){if(re(),typeof globalThis.crypto>"u"\|\|typeof globalThis.crypto.subtle?.exportKey!="function")throw new Error("No key export implementation could be found")}async function _e(){if(re(),typeof globalThis.crypto>"u"\|\|typeof globalThis.crypto.subtle?.sign!="function")throw new Error("No signing implementation could be found")}async function te(e){if(await we(),e.type!=="public"\|\|e.algorithm.name!=="Ed25519")throw new Error("The `CryptoKey` must be an `Ed25519` public key");let r=await crypto.subtle.exportKey("raw",e),[t]=L().deserialize(new Uint8Array(r));return t}async function ne(e,r){await _e();let t=await crypto.subtle.sign("Ed25519",e,r);return new Uint8Array(t)}var S=(e=>(e[e.WRITABLE_SIGNER=3]="WRITABLE_SIGNER",e[e.READONLY_SIGNER=2]="READONLY_SIGNER",e[e.WRITABLE=1]="WRITABLE",e[e.READONLY=0]="READONLY",e))(S\|\|{});var Ce=1;function z(e){return e>=2}function I(e){return (e&Ce)!==0}function G(e,r){return e\|r}function oe(e,r,t){e[r]=t(e[r]??{role:S.READONLY});}var p=Symbol("AddressMapTypeProperty");function se(e,r){let t={[e]:{[p]:0,role:S.WRITABLE_SIGNER}},n=new Set;for(let o of r){oe(t,o.programAddress,i=>{if(n.add(o.programAddress),p in i){if(I(i.role))switch(i[p]){case 0:throw new Error(`This transaction includes an address (\`${o.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`);default:throw new Error(`This transaction includes an address (\`${o.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`)}if(i[p]===2)return i}return {[p]:2,role:S.READONLY}});let s;if(o.accounts)for(let i of o.accounts)oe(t,i.address,c=>{let{address:l,...d}=i;if(p in c)switch(c[p]){case 0:return c;case 1:{let u=G(c.role,d.role);if("lookupTableAddress"in d){if(c.lookupTableAddress!==d.lookupTableAddress&&(s\|\|(s=O()))(d.lookupTableAddress,c.lookupTableAddress)<0)return {[p]:1,...d,role:u}}else if(z(d.role))return {[p]:2,role:u};return c.role!==u?{...c,role:u}:c}case 2:{let u=G(c.role,d.role);if(n.has(i.address)){if(I(d.role))throw new Error(`This transaction includes an address (\`${i.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`);return c.role!==u?{...c,role:u}:c}else return "lookupTableAddress"in d&&!z(c.role)?{...d,[p]:1,role:u}:c.role!==u?{...c,role:u}:c}}return "lookupTableAddress"in d?{...d,[p]:1}:{...d,[p]:2}});}return t}function ie(e){let r;return Object.entries(e).sort(([n,o],[s,i])=>{if(o[p]!==i[p]){if(o[p]===0)return -1;if(i[p]===0)return 1;if(o[p]===2)return -1;if(i[p]===2)return 1}let c=z(o.role);if(c!==z(i.role))return c?-1:1;let l=I(o.role);return l!==I(i.role)?l?-1:1:(r\|\|(r=O()),o[p]===1&&i[p]===1&&o.lookupTableAddress!==i.lookupTableAddress?r(o.lookupTableAddress,i.lookupTableAddress):r(n,s))}).map(([n,o])=>({address:n,...o}))}function ae(e){var t;let r={};for(let n of e){if(!("lookupTableAddress"in n))continue;let o=r[t=n.lookupTableAddress]\|\|(r[t]={readableIndices:[],writableIndices:[]});n.role===S.WRITABLE?o.writableIndices.push(n.addressIndex):o.readableIndices.push(n.addressIndex);}return Object.keys(r).sort(O()).map(n=>({lookupTableAddress:n,...r[n]}))}function ce(e){let r=0,t=0,n=0;for(let o of e){if("lookupTableAddress"in o)break;let s=I(o.role);z(o.role)?(n++,s\|\|t++):s\|\|r++;}return {numReadonlyNonSignerAccounts:r,numReadonlySignerAccounts:t,numSignerAccounts:n}}function Be(e){let r={};for(let[t,n]of e.entries())r[n.address]=t;return r}function de(e,r){let t=Be(r);return e.map(({accounts:n,data:o,programAddress:s})=>({programAddressIndex:t[s],...n?{accountIndices:n.map(({address:i})=>t[i])}:null,...o?{data:o}:null}))}function le(e){return "nonce"in e?e.nonce:e.blockhash}function ue(e){let r=e.findIndex(n=>"lookupTableAddress"in n);return (r===-1?e:e.slice(0,r)).map(({address:n})=>n)}function pe(e){let r=se(e.feePayer,e.instructions),t=ie(r);return {...e.version!=="legacy"?{addressTableLookups:ae(t)}:null,header:ce(t),instructions:de(e.instructions,t),lifetimeToken:le(e.lifetimeConstraint),staticAccounts:ue(t),version:e.version}}function me(){return b([["lookupTableAddress",L(void 0)],["writableIndices",h(y(),{size:T()})],["readableIndices",h(y(),{size:T()})]],void 0)}function fe(){return b([["numSignerAccounts",y(void 0)],["numReadonlySignerAccounts",y(void 0)],["numReadonlyNonSignerAccounts",y(void 0)]],void 0)}function ge(){return B(b([["programAddressIndex",y(void 0)],["addressIndices",h(y({description:""}),{description:"",size:T()})],["data",j({description:"",size:T()})]]),e=>e.addressIndices!==void 0&&e.data!==void 0?e:{...e,addressIndices:e.addressIndices??[],data:e.data??new Uint8Array(0)},e=>{if(e.addressIndices.length&&e.data.byteLength)return e;let{addressIndices:r,data:t,...n}=e;return {...n,...r.length?{addressIndices:r}:null,...t.byteLength?{data:t}:null}})}function ke(e,r){let t=r+e[0].toUpperCase()+e.slice(1);return new Error(`No ${e} exists for ${r}. Use \`get${t}()\` if you need a ${e}, and \`get${r}Codec()\` if you need to both encode and decode ${r}`)}function ye(e){return ()=>{throw ke("decoder",e)}}var H=128,Re={description:"",fixedSize:null,maxSize:1};function Me(e,r=0){let t=e[r];return t&H?[t^H,r+1]:["legacy",r]}function Le(e){if(e==="legacy")return new Uint8Array;if(e<0\|\|e>127)throw new Error(`Transaction version must be in the range [0, 127]. \`${e}\` given.`);return new Uint8Array([e\|H])}function Te(){return {...Re,deserialize:Me,serialize:Le}}var Oe={description:"",fixedSize:null,maxSize:null};function Pe(e){return e.version==="legacy"?b(he()).serialize(e):B(b([...he(),["addressTableLookups",ve()]]),r=>r.version==="legacy"?r:{...r,addressTableLookups:r.addressTableLookups??[]}).serialize(e)}function he(){return [["version",Te()],["header",fe()],["staticAccounts",h(L(),{description:"",size:T()})],["lifetimeToken",M({description:"",encoding:k,size:32})],["instructions",h(ge(),{description:"",size:T()})]]}function ve(){return h(me(),{size:T()})}function be(){return {...Oe,deserialize:ye("CompiledMessage"),serialize:Pe}}async function De(e,r){let t=be().serialize(e);return await ne(r,t)}async function uo(e,r){let t=pe(r),[n,o]=await Promise.all([te(e.publicKey),De(t,e.privateKey)]),s={..."signatures"in r?r.signatures:null,[n]:o},i={...r,signatures:s};return Object.freeze(i),i}

		exports.appendTransactionInstruction = m;
		exports.createTransaction = T;
		exports.prependTransactionInstruction = x;
		exports.setTransactionFeePayer = d;
		exports.appendTransactionInstruction = je;
		exports.createTransaction = $e;
		exports.prependTransactionInstruction = Ge;
		exports.setTransactionFeePayer = Fe;
		exports.signTransaction = uo;

		@@ -13,0 +14,0 @@ return exports;

dist/types/signatures.d.ts

		@@ -1,5 +0,3 @@
		import { Base58EncodedAddress } from '@solana/keys';
		type Base64EncodedSignature = string & {
		readonly __base64EncodedSignature: unique symbol;
		};
		import { Base58EncodedAddress, Ed25519Signature } from '@solana/keys';
		import { compileMessage } from './message';
		export interface IFullySignedTransaction extends ITransactionWithSignatures {
		@@ -9,5 +7,7 @@ readonly __fullySignedTransaction: unique symbol;
		export interface ITransactionWithSignatures {
		readonly signatures: Readonly<Record<Base58EncodedAddress, Base64EncodedSignature>>;
		readonly signatures: {
		readonly [publicKey: Base58EncodedAddress]: Ed25519Signature;
		};
		}
		export {};
		export declare function signTransaction<TTransaction extends Parameters<typeof compileMessage>[0]>(keyPair: CryptoKeyPair, transaction: TTransaction \| (TTransaction & ITransactionWithSignatures)): Promise<TTransaction & ITransactionWithSignatures>;
		//# sourceMappingURL=signatures.d.ts.map

package.json

		{
		"name": "@solana/transactions",
		"version": "2.0.0-experimental.6cedd3a",
		"version": "2.0.0-experimental.71b920d",
		"description": "Helpers for creating and serializing transactions",
		@@ -50,3 +50,3 @@ "exports": {
		"@metaplex-foundation/umi-serializers": "^0.8.2",
		"@solana/keys": "2.0.0-experimental.6cedd3a"
		"@solana/keys": "2.0.0-experimental.71b920d"
		},
		@@ -72,5 +72,5 @@ "devDependencies": {
		"version-from-git": "^1.1.1",
		"@solana/instructions": "2.0.0-experimental.6cedd3a",
		"@solana/keys": "2.0.0-experimental.6cedd3a",
		"@solana/rpc-core": "2.0.0-experimental.6cedd3a",
		"@solana/instructions": "2.0.0-experimental.71b920d",
		"@solana/keys": "2.0.0-experimental.71b920d",
		"@solana/rpc-core": "2.0.0-experimental.71b920d",
		"build-scripts": "0.0.0",
		@@ -77,0 +77,0 @@ "test-config": "0.0.0",

./dist/index.node.cjs