Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

@solana/transactions

Package Overview
Dependencies
Maintainers
13
Versions
1304
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@solana/transactions - npm Package Compare versions

Comparing version 2.0.0-experimental.9bf9fdb to 2.0.0-experimental.9ea7d74

dist/types/accounts.d.ts

633

dist/index.browser.js

@@ -0,1 +1,27 @@

import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
// ../build-scripts/env-shim.ts
var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
function assertIsBlockhash(putativeBlockhash) {
try {
if (
// Lowest value (32 bytes of zeroes)
putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
putativeBlockhash.length > 44
) {
throw new Error("Expected input string to decode to a byte array of length 32.");
}
const bytes3 = base58.serialize(putativeBlockhash);
const numBytes = bytes3.byteLength;
if (numBytes !== 32) {
throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
}
} catch (e) {
throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
cause: e
});
}
}
// src/create-transaction.ts

@@ -73,4 +99,605 @@ function createTransaction({

export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.browser.js.map
// ../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(bytes3, offset = 0) {
const firstByte = bytes3[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;
}
// src/compile-transaction.ts
function getCompiledTransaction(transaction) {
const compiledMessage = compileMessage(transaction);
let signatures;
if ("signatures" in transaction) {
signatures = [];
for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
}
} else {
signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
}
return {
compiledMessage,
signatures
};
}
// src/serializers/transaction.ts
var BASE_CONFIG3 = {
description: __DEV__ ? "The wire format of a Solana transaction" : "",
fixedSize: null,
maxSize: null
};
function serialize3(transaction) {
const compiledTransaction = getCompiledTransaction(transaction);
return struct([
[
"signatures",
array(bytes({ size: 64 }), {
...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
size: shortU16()
})
],
["compiledMessage", getCompiledMessageEncoder()]
]).serialize(compiledTransaction);
}
function getTransactionEncoder() {
return {
...BASE_CONFIG3,
deserialize: getUnimplementedDecoder("CompiledMessage"),
serialize: serialize3
};
}
// src/wire-transaction.ts
function getBase64EncodedWireTransaction(transaction) {
const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
{
return btoa(String.fromCharCode(...wireTransactionBytes));
}
}
export { appendTransactionInstruction, assertIsBlockhash, createTransaction, getBase64EncodedWireTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };

@@ -5,2 +5,515 @@ 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;
};
// ../../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.5/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.5/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.5/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.5/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.5/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.5/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.5/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];
}
};
}
// src/blockhash.ts
function assertIsBlockhash(putativeBlockhash) {
try {
if (
// Lowest value (32 bytes of zeroes)
putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
putativeBlockhash.length > 44
) {
throw new Error("Expected input string to decode to a byte array of length 32.");
}
const bytes2 = base58.serialize(putativeBlockhash);
const numBytes = bytes2.byteLength;
if (numBytes !== 32) {
throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
}
} catch (e) {
throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
cause: e
});
}
}
// src/create-transaction.ts

@@ -77,7 +590,673 @@ function createTransaction({

}
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;
}
// src/compile-transaction.ts
function getCompiledTransaction(transaction) {
const compiledMessage = compileMessage(transaction);
let signatures;
if ("signatures" in transaction) {
signatures = [];
for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
}
} else {
signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
}
return {
compiledMessage,
signatures
};
}
// src/serializers/transaction.ts
var BASE_CONFIG3 = {
description: "The wire format of a Solana transaction" ,
fixedSize: null,
maxSize: null
};
function serialize3(transaction) {
const compiledTransaction = getCompiledTransaction(transaction);
return struct([
[
"signatures",
array(bytes({ size: 64 }), {
...{ description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } ,
size: shortU16()
})
],
["compiledMessage", getCompiledMessageEncoder()]
]).serialize(compiledTransaction);
}
function getTransactionEncoder() {
return {
...BASE_CONFIG3,
deserialize: getUnimplementedDecoder("CompiledMessage"),
serialize: serialize3
};
}
// src/wire-transaction.ts
function getBase64EncodedWireTransaction(transaction) {
const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
{
return btoa(String.fromCharCode(...wireTransactionBytes));
}
}
exports.appendTransactionInstruction = appendTransactionInstruction;
exports.assertIsBlockhash = assertIsBlockhash;
exports.createTransaction = createTransaction;
exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
exports.prependTransactionInstruction = prependTransactionInstruction;
exports.setTransactionFeePayer = setTransactionFeePayer;
exports.signTransaction = signTransaction;

@@ -84,0 +1263,0 @@ return exports;

@@ -0,1 +1,27 @@

import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
// ../build-scripts/env-shim.ts
var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
function assertIsBlockhash(putativeBlockhash) {
try {
if (
// Lowest value (32 bytes of zeroes)
putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
putativeBlockhash.length > 44
) {
throw new Error("Expected input string to decode to a byte array of length 32.");
}
const bytes3 = base58.serialize(putativeBlockhash);
const numBytes = bytes3.byteLength;
if (numBytes !== 32) {
throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
}
} catch (e) {
throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
cause: e
});
}
}
// src/create-transaction.ts

@@ -73,4 +99,607 @@ 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(bytes3, offset = 0) {
const firstByte = bytes3[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;
}
// src/compile-transaction.ts
function getCompiledTransaction(transaction) {
const compiledMessage = compileMessage(transaction);
let signatures;
if ("signatures" in transaction) {
signatures = [];
for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
}
} else {
signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
}
return {
compiledMessage,
signatures
};
}
// src/serializers/transaction.ts
var BASE_CONFIG3 = {
description: __DEV__ ? "The wire format of a Solana transaction" : "",
fixedSize: null,
maxSize: null
};
function serialize3(transaction) {
const compiledTransaction = getCompiledTransaction(transaction);
return struct([
[
"signatures",
array(bytes({ size: 64 }), {
...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
size: shortU16()
})
],
["compiledMessage", getCompiledMessageEncoder()]
]).serialize(compiledTransaction);
}
function getTransactionEncoder() {
return {
...BASE_CONFIG3,
deserialize: getUnimplementedDecoder("CompiledMessage"),
serialize: serialize3
};
}
// src/wire-transaction.ts
function getBase64EncodedWireTransaction(transaction) {
const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
{
return btoa(String.fromCharCode(...wireTransactionBytes));
}
}
export { appendTransactionInstruction, assertIsBlockhash, createTransaction, getBase64EncodedWireTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.native.js.map

@@ -0,1 +1,27 @@

import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
import { getBase58EncodedAddressFromPublicKey, signBytes, getBase58EncodedAddressComparator, getBase58EncodedAddressCodec } from '@solana/keys';
// ../build-scripts/env-shim.ts
var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
function assertIsBlockhash(putativeBlockhash) {
try {
if (
// Lowest value (32 bytes of zeroes)
putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
putativeBlockhash.length > 44
) {
throw new Error("Expected input string to decode to a byte array of length 32.");
}
const bytes3 = base58.serialize(putativeBlockhash);
const numBytes = bytes3.byteLength;
if (numBytes !== 32) {
throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
}
} catch (e) {
throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
cause: e
});
}
}
// src/create-transaction.ts

@@ -73,4 +99,607 @@ 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(bytes3, offset = 0) {
const firstByte = bytes3[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;
}
// src/compile-transaction.ts
function getCompiledTransaction(transaction) {
const compiledMessage = compileMessage(transaction);
let signatures;
if ("signatures" in transaction) {
signatures = [];
for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
}
} else {
signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
}
return {
compiledMessage,
signatures
};
}
// src/serializers/transaction.ts
var BASE_CONFIG3 = {
description: __DEV__ ? "The wire format of a Solana transaction" : "",
fixedSize: null,
maxSize: null
};
function serialize3(transaction) {
const compiledTransaction = getCompiledTransaction(transaction);
return struct([
[
"signatures",
array(bytes({ size: 64 }), {
...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
size: shortU16()
})
],
["compiledMessage", getCompiledMessageEncoder()]
]).serialize(compiledTransaction);
}
function getTransactionEncoder() {
return {
...BASE_CONFIG3,
deserialize: getUnimplementedDecoder("CompiledMessage"),
serialize: serialize3
};
}
// src/wire-transaction.ts
function getBase64EncodedWireTransaction(transaction) {
const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
{
return Buffer.from(wireTransactionBytes).toString("base64");
}
}
export { appendTransactionInstruction, assertIsBlockhash, createTransaction, getBase64EncodedWireTransaction, prependTransactionInstruction, setTransactionFeePayer, signTransaction };
//# sourceMappingURL=out.js.map
//# sourceMappingURL=index.node.js.map

13

dist/index.production.min.js

@@ -5,8 +5,11 @@ 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 xe=Object.defineProperty;var Se=(e,r,t)=>r in e?xe(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var g=(e,r,t)=>(Se(e,typeof r!="symbol"?r+"":r,t),t);var A=e=>{let r=e.reduce((o,i)=>o+i.length,0),t=new Uint8Array(r),n=0;return e.forEach(o=>{t.set(o,n),n+=o.length;}),t},Z=(e,r)=>{if(e.length>=r)return e;let t=new Uint8Array(r).fill(0);return t.set(e),t},v=(e,r)=>Z(e.slice(0,r),r);var E=class extends Error{constructor(t){super(`Serializer [${t}] cannot deserialize empty buffers.`);g(this,"name","DeserializingEmptyBufferError");}},h=class extends Error{constructor(t,n,o){super(`Serializer [${t}] expected ${n} bytes, got ${o}.`);g(this,"name","NotEnoughBytesError");}},x=class extends Error{constructor(t){t??(t="Expected a fixed-size serializer, got a variable-size one.");super(t);g(this,"name","ExpectedFixedSizeSerializerError");}};function B(e,r,t){return {description:t??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r,serialize:n=>v(e.serialize(n),r),deserialize:(n,o=0)=>{if(n=n.slice(o,o+r),n.length<r)throw new h("fixSerializer",r,n.length);e.fixedSize!==null&&(n=v(n,e.fixedSize));let[i]=e.deserialize(n,0);return [i,o+r]}}}function k(e,r,t){return {description:e.description,fixedSize:e.fixedSize,maxSize:e.maxSize,serialize:n=>e.serialize(r(n)),deserialize:(n,o=0)=>{let[i,s]=e.deserialize(n,o);return t?[t(i,n,o),s]:[i,s]}}}var D=class extends Error{constructor(t,n,o){let i=`Expected a string of base ${n}, got [${t}].`;super(i);g(this,"name","InvalidBaseStringError");this.cause=o;}};var Q=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 D(n,r);if(n==="")return new Uint8Array;let o=[...n],i=o.findIndex(f=>f!==e[0]);i=i===-1?o.length:i;let s=Array(i).fill(0);if(i===o.length)return Uint8Array.from(s);let c=o.slice(i),l=0n,d=1n;for(let f=c.length-1;f>=0;f-=1)l+=d*BigInt(e.indexOf(c[f])),d*=t;let u=[];for(;l>0n;)u.unshift(Number(l%256n)),l/=256n;return Uint8Array.from(s.concat(u))},deserialize(n,o=0){if(n.length===0)return ["",0];let i=n.slice(o),s=i.findIndex(u=>u!==0);s=s===-1?i.length:s;let c=e[0].repeat(s);if(s===i.length)return [c,n.length];let l=i.slice(s).reduce((u,f)=>u*256n+BigInt(f),0n),d=[];for(;l>0n;)d.unshift(e[Number(l%t)]),l/=t;return [c+d.join(""),n.length]}}};var S=Q("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");var ee=e=>e.replace(/\u0000/g,"");var G={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 [ee(t),e.length]}};var V;(function(e){e.Little="le",e.Big="be";})(V||(V={}));var N=class extends RangeError{constructor(t,n,o,i){super(`Serializer [${t}] expected number to be between ${n} and ${o}, got ${i}.`);g(this,"name","NumberOutOfRangeError");}};function W(e){let r,t=e.name;return e.size>1&&(r=!("endian"in e.options)||e.options.endian===V.Little,t+=r?"(le)":"(be)"),{description:e.options.description??t,fixedSize:e.size,maxSize:e.size,serialize(n){e.range&&H(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 i=n.slice(o,o+e.size);we("i8",i,e.size);let s=Ie(i);return [e.get(s,r),o+e.size]}}}var ze=e=>e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset),Ie=e=>new DataView(ze(e)),H=(e,r,t,n)=>{if(n<r||n>t)throw new N(e,r,t,n)},we=(e,r,t)=>{if(r.length===0)throw new E(e);if(r.length<t)throw new h(e,t,r.length)};var b=(e={})=>W({name:"u8",size:1,range:[0,+"0xff"],set:(r,t)=>r.setUint8(0,Number(t)),get:r=>r.getUint8(0),options:e});var M=(e={})=>W({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 m=(e={})=>({description:e.description??"shortU16",fixedSize:null,maxSize:3,serialize:r=>{H("shortU16",0,65535,r);let t=[0];for(let n=0;;n+=1){let o=r>>n*7;if(o===0)break;let i=127&o;t[n]=i,n>0&&(t[n-1]|=128);}return new Uint8Array(t)},deserialize:(r,t=0)=>{let n=0,o=0;for(;++o;){let i=o-1,s=r[t+i],c=127&s;if(n|=c<<i*7,!(s&128))break}return [n,t+o]}});var $=class extends Error{constructor(t,n,o){super(`Expected [${t}] to have ${n} items, got ${o}.`);g(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.`);g(this,"name","InvalidArrayLikeRemainderSizeError");}},F=class extends Error{constructor(t){super(`Unrecognized array-like serializer size: ${JSON.stringify(t)}`);g(this,"name","UnrecognizedArrayLikeSerializerSizeError");}};function _(e){return e.reduce((r,t)=>r===null||t===null?null:r+t,0)}function re(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=_(r);if(o===null)throw new x('Serializers of "remainder" size must have fixed-size items.');let i=t.slice(n).length;if(i%o!==0)throw new U(i,o);return [i/o,n]}throw new F(e)}function C(e){return typeof e=="object"?e.description:`${e}`}function q(e,r){if(typeof e!="number")return null;if(e===0)return 0;let t=_(r);return t===null?null:t*e}function te(e,r){return typeof e=="object"?e.serialize(r):new Uint8Array}function y(e,r={}){let t=r.size??M();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}; ${C(t)})`,fixedSize:q(t,[e.fixedSize]),maxSize:q(t,[e.maxSize]),serialize:n=>{if(typeof t=="number"&&n.length!==t)throw new $("array",t,n.length);return A([te(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[i,s]=re(t,[e.fixedSize],n,o);o=s;let c=[];for(let l=0;l<i;l+=1){let[d,u]=e.deserialize(n,o);c.push(d),o=u;}return [c,o]}}}function R(e={}){let r=e.size??"variable",t=e.description??`bytes(${C(r)})`,n={description:t,fixedSize:null,maxSize:null,serialize:o=>new Uint8Array(o),deserialize:(o,i=0)=>{let s=o.slice(i);return [s,i+s.length]}};return r==="variable"?n:typeof r=="number"?B(n,r,t):{description:t,fixedSize:null,maxSize:null,serialize:o=>{let i=n.serialize(o),s=r.serialize(i.length);return A([s,i])},deserialize:(o,i=0)=>{if(o.slice(i).length===0)throw new E("bytes");let[s,c]=r.deserialize(o,i),l=Number(s);i=c;let d=o.slice(i,i+l);if(d.length<l)throw new h("bytes",l,d.length);let[u,f]=n.deserialize(d);return i+=f,[u,i]}}}function L(e={}){let r=e.size??M(),t=e.encoding??G,n=e.description??`string(${t.description}; ${C(r)})`;return r==="variable"?{...t,description:n}:typeof r=="number"?B(t,r,n):{description:n,fixedSize:null,maxSize:null,serialize:o=>{let i=t.serialize(o),s=r.serialize(i.length);return A([s,i])},deserialize:(o,i=0)=>{if(o.slice(i).length===0)throw new E("string");let[s,c]=r.deserialize(o,i),l=Number(s);i=c;let d=o.slice(i,i+l);if(d.length<l)throw new h("string",l,d.length);let[u,f]=t.deserialize(d);return i+=f,[u,i]}}}function T(e,r={}){let t=e.map(([n,o])=>`${String(n)}: ${o.description}`).join(", ");return {description:r.description??`struct(${t})`,fixedSize:_(e.map(([,n])=>n.fixedSize)),maxSize:_(e.map(([,n])=>n.maxSize)),serialize:n=>{let o=e.map(([i,s])=>s.serialize(n[i]));return A(o)},deserialize:(n,o=0)=>{let i={};return e.forEach(([s,c])=>{let[l,d]=c.deserialize(n,o);o=d,i[s]=l;}),[i,o]}}}function Pt(e){try{if(e.length<32||e.length>44)throw new Error("Expected input string to decode to a byte array of length 32.");let t=S.serialize(e).byteLength;if(t!==32)throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${t}`)}catch(r){throw new Error(`\`${e}\` is not a blockhash`,{cause:r})}}function Vt({version:e}){let r={instructions:[],version:e};return Object.freeze(r),r}function $t(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 ne(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 Kt(e,r){let t=[...r.instructions,e],n=ne(r,t);return Object.freeze(n),n}function Yt(e,r){let t=[e,...r.instructions],n=ne(r,t);return Object.freeze(n),n}function O(e){return L({description:e?.description??(""),encoding:S,size:32})}function P(){return new Intl.Collator("en",{caseFirst:"lower",ignorePunctuation:!1,localeMatcher:"best fit",numeric:!1,sensitivity:"variant",usage:"sort"}).compare}function oe(){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 Ce(){if(oe(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.exportKey!="function")throw new Error("No key export implementation could be found")}async function Be(){if(oe(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.sign!="function")throw new Error("No signing implementation could be found")}async function ie(e){if(await Ce(),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]=O().deserialize(new Uint8Array(r));return t}async function se(e,r){await Be();let t=await crypto.subtle.sign("Ed25519",e,r);return new Uint8Array(t)}var z=(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))(z||{});var ke=1;function I(e){return e>=2}function w(e){return (e&ke)!==0}function X(e,r){return e|r}function ae(e,r,t){e[r]=t(e[r]??{role:z.READONLY});}var p=Symbol("AddressMapTypeProperty");function ce(e,r){let t={[e]:{[p]:0,role:z.WRITABLE_SIGNER}},n=new Set;for(let o of r){ae(t,o.programAddress,s=>{if(n.add(o.programAddress),p in s){if(w(s.role))switch(s[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(s[p]===2)return s}return {[p]:2,role:z.READONLY}});let i;if(o.accounts)for(let s of o.accounts)ae(t,s.address,c=>{let{address:l,...d}=s;if(p in c)switch(c[p]){case 0:return c;case 1:{let u=X(c.role,d.role);if("lookupTableAddress"in d){if(c.lookupTableAddress!==d.lookupTableAddress&&(i||(i=P()))(d.lookupTableAddress,c.lookupTableAddress)<0)return {[p]:1,...d,role:u}}else if(I(d.role))return {[p]:2,role:u};return c.role!==u?{...c,role:u}:c}case 2:{let u=X(c.role,d.role);if(n.has(s.address)){if(w(d.role))throw new Error(`This transaction includes an address (\`${s.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&&!I(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 de(e){let r;return Object.entries(e).sort(([n,o],[i,s])=>{if(o[p]!==s[p]){if(o[p]===0)return -1;if(s[p]===0)return 1;if(o[p]===2)return -1;if(s[p]===2)return 1}let c=I(o.role);if(c!==I(s.role))return c?-1:1;let l=w(o.role);return l!==w(s.role)?l?-1:1:(r||(r=P()),o[p]===1&&s[p]===1&&o.lookupTableAddress!==s.lookupTableAddress?r(o.lookupTableAddress,s.lookupTableAddress):r(n,i))}).map(([n,o])=>({address:n,...o}))}function le(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===z.WRITABLE?o.writableIndices.push(n.addressIndex):o.readableIndices.push(n.addressIndex);}return Object.keys(r).sort(P()).map(n=>({lookupTableAddress:n,...r[n]}))}function ue(e){let r=0,t=0,n=0;for(let o of e){if("lookupTableAddress"in o)break;let i=w(o.role);I(o.role)?(n++,i||t++):i||r++;}return {numReadonlyNonSignerAccounts:r,numReadonlySignerAccounts:t,numSignerAccounts:n}}function Me(e){let r={};for(let[t,n]of e.entries())r[n.address]=t;return r}function pe(e,r){let t=Me(r);return e.map(({accounts:n,data:o,programAddress:i})=>({programAddressIndex:t[i],...n?{accountIndices:n.map(({address:s})=>t[s])}:null,...o?{data:o}:null}))}function me(e){return "nonce"in e?e.nonce:e.blockhash}function fe(e){let r=e.findIndex(n=>"lookupTableAddress"in n);return (r===-1?e:e.slice(0,r)).map(({address:n})=>n)}function K(e){let r=ce(e.feePayer,e.instructions),t=de(r);return {...e.version!=="legacy"?{addressTableLookups:le(t)}:null,header:ue(t),instructions:pe(e.instructions,t),lifetimeToken:me(e.lifetimeConstraint),staticAccounts:fe(t),version:e.version}}function ge(){return T([["lookupTableAddress",O(void 0)],["writableIndices",y(b(),{size:m()})],["readableIndices",y(b(),{size:m()})]],void 0)}function ye(){return T([["numSignerAccounts",b(void 0)],["numReadonlySignerAccounts",b(void 0)],["numReadonlyNonSignerAccounts",b(void 0)]],void 0)}function Te(){return k(T([["programAddressIndex",b(void 0)],["addressIndices",y(b({description:""}),{description:"",size:m()})],["data",R({description:"",size:m()})]]),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 Re(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 Y(e){return ()=>{throw Re("decoder",e)}}var J=128,Le={description:"",fixedSize:null,maxSize:1};function Oe(e,r=0){let t=e[r];return t&J?[t^J,r+1]:["legacy",r]}function Pe(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|J])}function he(){return {...Le,deserialize:Oe,serialize:Pe}}var ve={description:"",fixedSize:null,maxSize:null};function De(e){return e.version==="legacy"?T(be()).serialize(e):k(T([...be(),["addressTableLookups",Ve()]]),r=>r.version==="legacy"?r:{...r,addressTableLookups:r.addressTableLookups??[]}).serialize(e)}function be(){return [["version",he()],["header",ye()],["staticAccounts",y(O(),{description:"",size:m()})],["lifetimeToken",L({description:"",encoding:S,size:32})],["instructions",y(Te(),{description:"",size:m()})]]}function Ve(){return y(ge(),{size:m()})}function j(){return {...ve,deserialize:Y("CompiledMessage"),serialize:De}}async function Ne(e,r){let t=j().serialize(e);return await se(r,t)}async function bo(e,r){let t=K(r),[n,o]=await Promise.all([ie(e.publicKey),Ne(t,e.privateKey)]),i={..."signatures"in r?r.signatures:null,[n]:o},s={...r,signatures:i};return Object.freeze(s),s}function Ae(e){let r=K(e),t;if("signatures"in e){t=[];for(let n=0;n<r.header.numSignerAccounts;n++)t[n]=e.signatures[r.staticAccounts[n]]??new Uint8Array(Array(64).fill(0));}else t=Array(r.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));return {compiledMessage:r,signatures:t}}var We={description:"",fixedSize:null,maxSize:null};function $e(e){let r=Ae(e);return T([["signatures",y(R({size:64}),{size:m()})],["compiledMessage",j()]]).serialize(r)}function Ee(){return {...We,deserialize:Y("CompiledMessage"),serialize:$e}}function Oo(e){let r=Ee().serialize(e);return btoa(String.fromCharCode(...r))}
exports.appendTransactionInstruction = m;
exports.createTransaction = T;
exports.prependTransactionInstruction = x;
exports.setTransactionFeePayer = d;
exports.appendTransactionInstruction = Kt;
exports.assertIsBlockhash = Pt;
exports.createTransaction = Vt;
exports.getBase64EncodedWireTransaction = Oo;
exports.prependTransactionInstruction = Yt;
exports.setTransactionFeePayer = $t;
exports.signTransaction = bo;

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

@@ -1,2 +0,4 @@

import { Blockhash } from '@solana/rpc-core';
export type Blockhash = string & {
readonly __blockhash: unique symbol;
};
type BlockhashLifetimeConstraint = Readonly<{

@@ -9,3 +11,4 @@ blockhash: Blockhash;

}
export declare function assertIsBlockhash(putativeBlockhash: string): asserts putativeBlockhash is Blockhash;
export {};
//# sourceMappingURL=blockhash.d.ts.map

@@ -8,2 +8,3 @@ export * from './blockhash';

export * from './types';
export * from './wire-transaction';
//# sourceMappingURL=index.d.ts.map

@@ -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
{
"name": "@solana/transactions",
"version": "2.0.0-experimental.9bf9fdb",
"version": "2.0.0-experimental.9ea7d74",
"description": "Helpers for creating and serializing transactions",

@@ -49,14 +49,14 @@ "exports": {

"dependencies": {
"@metaplex-foundation/umi-serializers": "^0.8.2",
"@solana/keys": "2.0.0-experimental.9bf9fdb"
"@metaplex-foundation/umi-serializers": "^0.8.5",
"@solana/keys": "2.0.0-experimental.9ea7d74"
},
"devDependencies": {
"@solana/eslint-config-solana": "^1.0.0",
"@solana/eslint-config-solana": "^1.0.2",
"@swc/core": "^1.3.18",
"@swc/jest": "^0.2.23",
"@types/jest": "^29.5.2",
"@typescript-eslint/eslint-plugin": "^5.57.1",
"@typescript-eslint/parser": "^5.57.1",
"@typescript-eslint/eslint-plugin": "^6.0.0",
"@typescript-eslint/parser": "^6.0.0",
"agadoo": "^3.0.0",
"eslint": "^8.37.0",
"eslint": "^8.45.0",
"eslint-plugin-sort-keys-fix": "^1.1.2",

@@ -70,7 +70,5 @@ "jest": "^29.6.1",

"tsup": "6.7.0",
"typescript": "^5.0.3",
"typescript": "^5.1.6",
"version-from-git": "^1.1.1",
"@solana/instructions": "2.0.0-experimental.9bf9fdb",
"@solana/keys": "2.0.0-experimental.9bf9fdb",
"@solana/rpc-core": "2.0.0-experimental.9bf9fdb",
"@solana/instructions": "2.0.0-experimental.9ea7d74",
"build-scripts": "0.0.0",

@@ -77,0 +75,0 @@ "test-config": "0.0.0",

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc