@solana/transactions 2.0.0-experimental.9bf9fdb → 2.0.0-experimental.9e133fd

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. package/LICENSE +1 -1
  2. package/dist/index.browser.cjs +815 -41
  3. package/dist/index.browser.cjs.map +1 -1
  4. package/dist/index.browser.js +803 -42
  5. package/dist/index.browser.js.map +1 -1
  6. package/dist/index.development.js +1784 -41
  7. package/dist/index.development.js.map +1 -1
  8. package/dist/index.native.js +803 -42
  9. package/dist/index.native.js.map +1 -1
  10. package/dist/index.node.cjs +813 -41
  11. package/dist/index.node.cjs.map +1 -1
  12. package/dist/index.node.js +803 -42
  13. package/dist/index.node.js.map +1 -1
  14. package/dist/index.production.min.js +16 -5
  15. package/dist/types/accounts.d.ts +28 -0
  16. package/dist/types/blockhash.d.ts +9 -1
  17. package/dist/types/compile-address-table-lookups.d.ts +10 -0
  18. package/dist/types/compile-header.d.ts +9 -0
  19. package/dist/types/compile-instructions.d.ts +10 -0
  20. package/dist/types/compile-lifetime-token.d.ts +3 -0
  21. package/dist/types/compile-static-accounts.d.ts +4 -0
  22. package/dist/types/compile-transaction.d.ts +11 -0
  23. package/dist/types/durable-nonce.d.ts +20 -7
  24. package/dist/types/fee-payer.d.ts +3 -2
  25. package/dist/types/index.d.ts +2 -0
  26. package/dist/types/message.d.ts +30 -0
  27. package/dist/types/serializers/address-table-lookup.d.ts +6 -0
  28. package/dist/types/serializers/header.d.ts +8 -0
  29. package/dist/types/serializers/index.d.ts +2 -0
  30. package/dist/types/serializers/instruction.d.ts +6 -0
  31. package/dist/types/serializers/message.d.ts +6 -0
  32. package/dist/types/serializers/transaction-version.d.ts +6 -0
  33. package/dist/types/serializers/transaction.d.ts +6 -0
  34. package/dist/types/serializers/unimplemented.d.ts +3 -0
  35. package/dist/types/signatures.d.ts +14 -7
  36. package/dist/types/types.d.ts +7 -0
  37. package/dist/types/unsigned-transaction.d.ts +4 -0
  38. package/dist/types/wire-transaction.d.ts +6 -0
  39. package/package.json +23 -22
package/dist/index.node.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"sources":["../src/create-transaction.ts","../src/fee-payer.ts","../src/instructions.ts"],"names":[],"mappings":";AASO,SAAS,kBAAuD;AAAA,EACnE;AACJ,GAA6C;AACzC,QAAM,MAAmB;AAAA,IACrB,cAAc,CAAC;AAAA,IACf;AAAA,EACJ;AACA,SAAO,OAAO,GAAG;AACjB,SAAO;AACX;;;ACTO,SAAS,uBACZ,UACA,aAOsG;AACtG,MAAI,cAAc,eAAe,aAAa,YAAY,UAAU;AAChE,WAAO;AAAA,EACX;AACA,MAAI;AACJ,MAAI,gBAAgB,aAAa;AAE7B,UAAM;AAAA,MACF,YAAY;AAAA;AAAA,MACZ,GAAG;AAAA,IACP,IAAI;AACJ,UAAM;AAAA,MACF,GAAG;AAAA,MACH;AAAA,IACJ;AAAA,EACJ,OAAO;AACH,UAAM;AAAA,MACF,GAAG;AAAA,MACH;AAAA,IACJ;AAAA,EACJ;AACA,SAAO,OAAO,GAAG;AACjB,SAAO;AACX;;;ACtCA,SAAS,oBACL,aACA,kBACmE;AACnE,MAAI;AACJ,MAAI,gBAAgB,aAAa;AAE7B,UAAM;AAAA,MACF,YAAY;AAAA;AAAA,MACZ,GAAG;AAAA,IACP,IAAI;AACJ,UAAM;AAAA,MACF,GAAG;AAAA,MACH,cAAc;AAAA,IAClB;AAAA,EACJ,OAAO;AACH,UAAM;AAAA,MACF,GAAG;AAAA,MACH,cAAc;AAAA,IAClB;AAAA,EACJ;AACA,SAAO;AACX;AAEO,SAAS,6BACZ,aACA,aACmE;AACnE,QAAM,mBAAmB,CAAC,GAAG,YAAY,cAAc,WAAW;AAClE,QAAM,MAAM,oBAAoB,aAAa,gBAAgB;AAC7D,SAAO,OAAO,GAAG;AACjB,SAAO;AACX;AAEO,SAAS,8BACZ,aACA,aACmE;AACnE,QAAM,mBAAmB,CAAC,aAAa,GAAG,YAAY,YAAY;AAClE,QAAM,MAAM,oBAAoB,aAAa,gBAAgB;AAC7D,SAAO,OAAO,GAAG;AACjB,SAAO;AACX","sourcesContent":["import { Transaction, TransactionVersion } from './types';\n\ntype TransactionConfig<TVersion extends TransactionVersion> = Readonly<{\n version: TVersion;\n}>;\n\nexport function createTransaction<TVersion extends TransactionVersion>(\n config: TransactionConfig<TVersion>\n): Extract<Transaction, { version: TVersion }>;\nexport function createTransaction<TVersion extends TransactionVersion>({\n version,\n}: TransactionConfig<TVersion>): Transaction {\n const out: Transaction = {\n instructions: [],\n version,\n };\n Object.freeze(out);\n return out;\n}\n","import { Base58EncodedAddress } from '@solana/keys';\n\nimport { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\n\nexport interface ITransactionWithFeePayer<TAddress extends string = string> {\n readonly feePayer: Base58EncodedAddress<TAddress>;\n}\n\nexport function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(\n feePayer: Base58EncodedAddress<TFeePayerAddress>,\n transaction:\n | TTransaction\n | (TTransaction & ITransactionWithFeePayer<TFeePayerAddress>)\n | (TTransaction & ITransactionWithSignatures)\n | (TTransaction & ITransactionWithFeePayer<TFeePayerAddress> & ITransactionWithSignatures)\n):\n | (TTransaction & ITransactionWithFeePayer<TFeePayerAddress>)\n | (Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithFeePayer<TFeePayerAddress>) {\n if ('feePayer' in transaction && feePayer === transaction.feePayer) {\n return transaction;\n }\n let out;\n if ('signatures' in transaction) {\n // The implication of the fee payer changing is that any existing signatures are invalid.\n const {\n signatures: _, // eslint-disable-line @typescript-eslint/no-unused-vars\n ...unsignedTransaction\n } = transaction;\n out = {\n ...unsignedTransaction,\n feePayer,\n };\n } else {\n out = {\n ...transaction,\n feePayer,\n };\n }\n Object.freeze(out);\n return out;\n}\n","import { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\n\nfunction replaceInstructions<TTransaction extends BaseTransaction, TInstructions>(\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures),\n nextInstructions: TInstructions\n): TTransaction | Omit<TTransaction, keyof ITransactionWithSignatures> {\n let out;\n if ('signatures' in transaction) {\n // The implication of the instructions changing is that any existing signatures are invalid.\n const {\n signatures: _, // eslint-disable-line @typescript-eslint/no-unused-vars\n ...unsignedTransaction\n } = transaction;\n out = {\n ...unsignedTransaction,\n instructions: nextInstructions,\n };\n } else {\n out = {\n ...transaction,\n instructions: nextInstructions,\n };\n }\n return out;\n}\n\nexport function appendTransactionInstruction<TTransaction extends BaseTransaction>(\n instruction: TTransaction['instructions'][number],\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): TTransaction | Omit<TTransaction, keyof ITransactionWithSignatures> {\n const nextInstructions = [...transaction.instructions, instruction] as const;\n const out = replaceInstructions(transaction, nextInstructions);\n Object.freeze(out);\n return out;\n}\n\nexport function prependTransactionInstruction<TTransaction extends BaseTransaction>(\n instruction: TTransaction['instructions'][number],\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): TTransaction | Omit<TTransaction, keyof ITransactionWithSignatures> {\n const nextInstructions = [instruction, ...transaction.instructions] as const;\n const out = replaceInstructions(transaction, nextInstructions);\n Object.freeze(out);\n return out;\n}\n"]}
1
+ {"version":3,"sources":["../../build-scripts/env-shim.ts","../src/blockhash.ts","../src/unsigned-transaction.ts","../src/create-transaction.ts","../../instructions/src/roles.ts","../src/durable-nonce.ts","../src/fee-payer.ts","../src/instructions.ts","../src/serializers/transaction.ts","../src/accounts.ts","../src/compile-address-table-lookups.ts","../src/compile-header.ts","../src/compile-instructions.ts","../src/compile-lifetime-token.ts","../src/compile-static-accounts.ts","../src/message.ts","../src/compile-transaction.ts","../src/serializers/message.ts","../src/serializers/address-table-lookup.ts","../src/serializers/header.ts","../src/serializers/instruction.ts","../src/serializers/transaction-version.ts","../src/serializers/unimplemented.ts","../src/signatures.ts","../src/wire-transaction.ts"],"names":["bytes","AccountRole","array","shortU16","struct","getAddressComparator","base58","mapSerializer","getAddressCodec","u8","BASE_CONFIG","serialize"],"mappings":"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","sourcesContent":["// Clever obfuscation to prevent the build system from inlining the value of `NODE_ENV`\nexport const __DEV__ = /* @__PURE__ */ (() => (process as any)['en' + 'v'].NODE_ENV === 'development')();\n","import { base58 } from '@metaplex-foundation/umi-serializers';\n\nimport { IDurableNonceTransaction } from './durable-nonce';\nimport { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\nimport { getUnsignedTransaction } from './unsigned-transaction';\n\nexport type Blockhash = string & { readonly __brand: unique symbol };\n\ntype BlockhashLifetimeConstraint = Readonly<{\n blockhash: Blockhash;\n lastValidBlockHeight: bigint;\n}>;\n\nexport interface ITransactionWithBlockhashLifetime {\n readonly lifetimeConstraint: BlockhashLifetimeConstraint;\n}\n\nexport function assertIsBlockhash(putativeBlockhash: string): asserts putativeBlockhash is Blockhash {\n try {\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest value (32 bytes of zeroes)\n putativeBlockhash.length < 32 ||\n // Highest value (32 bytes of 255)\n putativeBlockhash.length > 44\n ) {\n throw new Error('Expected input string to decode to a byte array of length 32.');\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base58.serialize(putativeBlockhash);\n const numBytes = bytes.byteLength;\n if (numBytes !== 32) {\n throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);\n }\n } catch (e) {\n throw new Error(`\\`${putativeBlockhash}\\` is not a blockhash`, {\n cause: e,\n });\n }\n}\n\nexport function setTransactionLifetimeUsingBlockhash<TTransaction extends BaseTransaction & IDurableNonceTransaction>(\n blockhashLifetimeConstraint: BlockhashLifetimeConstraint,\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): Omit<TTransaction, keyof ITransactionWithSignatures | 'lifetimeConstraint'> & ITransactionWithBlockhashLifetime;\n\nexport function setTransactionLifetimeUsingBlockhash<\n TTransaction extends BaseTransaction | (BaseTransaction & ITransactionWithBlockhashLifetime)\n>(\n blockhashLifetimeConstraint: BlockhashLifetimeConstraint,\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithBlockhashLifetime;\n\nexport function setTransactionLifetimeUsingBlockhash(\n blockhashLifetimeConstraint: BlockhashLifetimeConstraint,\n transaction: BaseTransaction | (BaseTransaction & ITransactionWithBlockhashLifetime)\n) {\n if (\n 'lifetimeConstraint' in transaction &&\n transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash &&\n transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight\n ) {\n return transaction;\n }\n const out = {\n ...getUnsignedTransaction(transaction),\n lifetimeConstraint: blockhashLifetimeConstraint,\n };\n Object.freeze(out);\n return out;\n}\n","import { ITransactionWithSignatures } from '.';\nimport { BaseTransaction } from './types';\n\nexport function getUnsignedTransaction<TTransaction extends BaseTransaction>(\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): TTransaction | Omit<TTransaction & ITransactionWithSignatures, keyof ITransactionWithSignatures> {\n if ('signatures' in transaction) {\n // The implication of the lifetime constraint changing is that any existing signatures are invalid.\n const {\n signatures: _, // eslint-disable-line @typescript-eslint/no-unused-vars\n ...unsignedTransaction\n } = transaction;\n return unsignedTransaction;\n } else {\n return transaction;\n }\n}\n","import { Transaction, TransactionVersion } from './types';\n\ntype TransactionConfig<TVersion extends TransactionVersion> = Readonly<{\n version: TVersion;\n}>;\n\nexport function createTransaction<TVersion extends TransactionVersion>(\n config: TransactionConfig<TVersion>\n): Extract<Transaction, { version: TVersion }>;\nexport function createTransaction<TVersion extends TransactionVersion>({\n version,\n}: TransactionConfig<TVersion>): Transaction {\n const out: Transaction = {\n instructions: [],\n version,\n };\n Object.freeze(out);\n return out;\n}\n","/**\n * Quick primer on bitwise operations: https://stackoverflow.com/a/1436448/802047\n */\n\nexport enum AccountRole {\n // Bitflag guide: is signer ⌄⌄ is writable\n WRITABLE_SIGNER = /* 3 */ 0b11, // prettier-ignore\n READONLY_SIGNER = /* 2 */ 0b10, // prettier-ignore\n WRITABLE = /* 1 */ 0b01, // prettier-ignore\n READONLY = /* 0 */ 0b00, // prettier-ignore\n}\n\nconst IS_SIGNER_BITMASK = 0b10;\nconst IS_WRITABLE_BITMASK = 0b01;\n\nexport function downgradeRoleToNonSigner(role: AccountRole.READONLY_SIGNER): AccountRole.READONLY;\nexport function downgradeRoleToNonSigner(role: AccountRole.WRITABLE_SIGNER): AccountRole.WRITABLE;\nexport function downgradeRoleToNonSigner(role: AccountRole): AccountRole;\nexport function downgradeRoleToNonSigner(role: AccountRole): AccountRole {\n return role & ~IS_SIGNER_BITMASK;\n}\n\nexport function downgradeRoleToReadonly(role: AccountRole.WRITABLE): AccountRole.READONLY;\nexport function downgradeRoleToReadonly(role: AccountRole.WRITABLE_SIGNER): AccountRole.READONLY_SIGNER;\nexport function downgradeRoleToReadonly(role: AccountRole): AccountRole;\nexport function downgradeRoleToReadonly(role: AccountRole): AccountRole {\n return role & ~IS_WRITABLE_BITMASK;\n}\n\nexport function isSignerRole(role: AccountRole): role is AccountRole.READONLY_SIGNER | AccountRole.WRITABLE_SIGNER {\n return role >= AccountRole.READONLY_SIGNER;\n}\n\nexport function isWritableRole(role: AccountRole): role is AccountRole.WRITABLE | AccountRole.WRITABLE_SIGNER {\n return (role & IS_WRITABLE_BITMASK) !== 0;\n}\n\nexport function mergeRoles(roleA: AccountRole.WRITABLE, roleB: AccountRole.READONLY_SIGNER): AccountRole.WRITABLE_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole.READONLY_SIGNER, roleB: AccountRole.WRITABLE): AccountRole.WRITABLE_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole, roleB: AccountRole.WRITABLE_SIGNER): AccountRole.WRITABLE_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole.WRITABLE_SIGNER, roleB: AccountRole): AccountRole.WRITABLE_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole, roleB: AccountRole.READONLY_SIGNER): AccountRole.READONLY_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole.READONLY_SIGNER, roleB: AccountRole): AccountRole.READONLY_SIGNER; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole, roleB: AccountRole.WRITABLE): AccountRole.WRITABLE; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole.WRITABLE, roleB: AccountRole): AccountRole.WRITABLE; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole.READONLY, roleB: AccountRole.READONLY): AccountRole.READONLY; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole, roleB: AccountRole): AccountRole; // prettier-ignore\nexport function mergeRoles(roleA: AccountRole, roleB: AccountRole): AccountRole {\n return roleA | roleB;\n}\n\nexport function upgradeRoleToSigner(role: AccountRole.READONLY): AccountRole.READONLY_SIGNER;\nexport function upgradeRoleToSigner(role: AccountRole.WRITABLE): AccountRole.WRITABLE_SIGNER;\nexport function upgradeRoleToSigner(role: AccountRole): AccountRole;\nexport function upgradeRoleToSigner(role: AccountRole): AccountRole {\n return role | IS_SIGNER_BITMASK;\n}\n\nexport function upgradeRoleToWritable(role: AccountRole.READONLY): AccountRole.WRITABLE;\nexport function upgradeRoleToWritable(role: AccountRole.READONLY_SIGNER): AccountRole.WRITABLE_SIGNER;\nexport function upgradeRoleToWritable(role: AccountRole): AccountRole;\nexport function upgradeRoleToWritable(role: AccountRole): AccountRole {\n return role | IS_WRITABLE_BITMASK;\n}\n","import { Base58EncodedAddress } from '@solana/addresses';\nimport { AccountRole, IInstruction, IInstructionWithAccounts, IInstructionWithData } from '@solana/instructions';\nimport { ReadonlyAccount, ReadonlySignerAccount, WritableAccount } from '@solana/instructions/dist/types/accounts';\n\nimport { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\nimport { getUnsignedTransaction } from './unsigned-transaction';\n\ntype AdvanceNonceAccountInstruction<\n TNonceAccountAddress extends string = string,\n TNonceAuthorityAddress extends string = string\n> = IInstruction<'11111111111111111111111111111111'> &\n IInstructionWithAccounts<\n readonly [\n WritableAccount<TNonceAccountAddress>,\n ReadonlyAccount<'SysvarRecentB1ockHashes11111111111111111111'>,\n ReadonlySignerAccount<TNonceAuthorityAddress>\n ]\n > &\n IInstructionWithData<AdvanceNonceAccountInstructionData>;\ntype AdvanceNonceAccountInstructionData = Uint8Array & {\n readonly __brand: unique symbol;\n};\ntype DurableNonceConfig<\n TNonceAccountAddress extends string = string,\n TNonceAuthorityAddress extends string = string,\n TNonceValue extends string = string\n> = Readonly<{\n readonly nonce: Nonce<TNonceValue>;\n readonly nonceAccountAddress: Base58EncodedAddress<TNonceAccountAddress>;\n readonly nonceAuthorityAddress: Base58EncodedAddress<TNonceAuthorityAddress>;\n}>;\nexport type Nonce<TNonceValue extends string = string> = TNonceValue & { readonly __brand: unique symbol };\ntype NonceLifetimeConstraint<TNonceValue extends string = string> = Readonly<{\n nonce: Nonce<TNonceValue>;\n}>;\n\nconst RECENT_BLOCKHASHES_SYSVAR_ADDRESS =\n 'SysvarRecentB1ockHashes11111111111111111111' as Base58EncodedAddress<'SysvarRecentB1ockHashes11111111111111111111'>;\nconst SYSTEM_PROGRAM_ADDRESS =\n '11111111111111111111111111111111' as Base58EncodedAddress<'11111111111111111111111111111111'>;\n\nexport interface IDurableNonceTransaction<\n TNonceAccountAddress extends string = string,\n TNonceAuthorityAddress extends string = string,\n TNonceValue extends string = string\n> {\n readonly instructions: readonly [\n // The first instruction *must* be the system program's `AdvanceNonceAccount` instruction.\n AdvanceNonceAccountInstruction<TNonceAccountAddress, TNonceAuthorityAddress>,\n ...IInstruction[]\n ];\n readonly lifetimeConstraint: NonceLifetimeConstraint<TNonceValue>;\n}\n\nexport function assertIsDurableNonceTransaction(\n transaction: BaseTransaction | (BaseTransaction & IDurableNonceTransaction)\n): asserts transaction is BaseTransaction & IDurableNonceTransaction {\n if (!isDurableNonceTransaction(transaction)) {\n // TODO: Coded error.\n throw new Error('Transaction is not a durable nonce transaction');\n }\n}\n\nfunction createAdvanceNonceAccountInstruction<\n TNonceAccountAddress extends string = string,\n TNonceAuthorityAddress extends string = string\n>(\n nonceAccountAddress: Base58EncodedAddress<TNonceAccountAddress>,\n nonceAuthorityAddress: Base58EncodedAddress<TNonceAuthorityAddress>\n): AdvanceNonceAccountInstruction<TNonceAccountAddress, TNonceAuthorityAddress> {\n return {\n accounts: [\n { address: nonceAccountAddress, role: AccountRole.WRITABLE },\n {\n address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,\n role: AccountRole.READONLY,\n },\n { address: nonceAuthorityAddress, role: AccountRole.READONLY_SIGNER },\n ],\n data: new Uint8Array([4, 0, 0, 0]) as AdvanceNonceAccountInstructionData,\n programAddress: SYSTEM_PROGRAM_ADDRESS,\n };\n}\n\nfunction isAdvanceNonceAccountInstruction(instruction: IInstruction): instruction is AdvanceNonceAccountInstruction {\n return (\n instruction.programAddress === SYSTEM_PROGRAM_ADDRESS &&\n // Test for `AdvanceNonceAccount` instruction data\n instruction.data != null &&\n isAdvanceNonceAccountInstructionData(instruction.data) &&\n // Test for exactly 3 accounts\n instruction.accounts?.length === 3 &&\n // First account is nonce account address\n instruction.accounts[0].address != null &&\n instruction.accounts[0].role === AccountRole.WRITABLE &&\n // Second account is recent blockhashes sysvar\n instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS &&\n instruction.accounts[1].role === AccountRole.READONLY &&\n // Third account is nonce authority account\n instruction.accounts[2].address != null &&\n instruction.accounts[2].role === AccountRole.READONLY_SIGNER\n );\n}\n\nfunction isAdvanceNonceAccountInstructionData(data: Uint8Array): data is AdvanceNonceAccountInstructionData {\n // AdvanceNonceAccount is the fifth instruction in the System Program (index 4)\n return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;\n}\n\nfunction isDurableNonceTransaction(\n transaction: BaseTransaction | (BaseTransaction & IDurableNonceTransaction)\n): transaction is BaseTransaction & IDurableNonceTransaction {\n return (\n 'lifetimeConstraint' in transaction &&\n typeof transaction.lifetimeConstraint.nonce === 'string' &&\n transaction.instructions[0] != null &&\n isAdvanceNonceAccountInstruction(transaction.instructions[0])\n );\n}\n\nexport function setTransactionLifetimeUsingDurableNonce<\n TTransaction extends BaseTransaction,\n TNonceAccountAddress extends string = string,\n TNonceAuthorityAddress extends string = string,\n TNonceValue extends string = string\n>(\n {\n nonce,\n nonceAccountAddress,\n nonceAuthorityAddress,\n }: DurableNonceConfig<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>,\n transaction: TTransaction | (TTransaction & IDurableNonceTransaction)\n): Omit<TTransaction, keyof ITransactionWithSignatures> &\n IDurableNonceTransaction<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue> {\n const isAlreadyDurableNonceTransaction = isDurableNonceTransaction(transaction);\n if (\n isAlreadyDurableNonceTransaction &&\n transaction.lifetimeConstraint.nonce === nonce &&\n transaction.instructions[0].accounts[0].address === nonceAccountAddress &&\n transaction.instructions[0].accounts[2].address === nonceAuthorityAddress\n ) {\n return transaction as TTransaction &\n IDurableNonceTransaction<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>;\n }\n const out = {\n ...getUnsignedTransaction(transaction),\n instructions: [\n createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),\n ...(isAlreadyDurableNonceTransaction ? transaction.instructions.slice(1) : transaction.instructions),\n ],\n lifetimeConstraint: {\n nonce,\n },\n } as TTransaction & IDurableNonceTransaction<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>;\n Object.freeze(out);\n return out;\n}\n","import { Base58EncodedAddress } from '@solana/addresses';\n\nimport { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\nimport { getUnsignedTransaction } from './unsigned-transaction';\n\nexport interface ITransactionWithFeePayer<TAddress extends string = string> {\n readonly feePayer: Base58EncodedAddress<TAddress>;\n}\n\nexport function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(\n feePayer: Base58EncodedAddress<TFeePayerAddress>,\n transaction:\n | (TTransaction & ITransactionWithSignatures)\n | (TTransaction & ITransactionWithFeePayer<string> & ITransactionWithSignatures)\n): Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithFeePayer<TFeePayerAddress>;\n\nexport function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(\n feePayer: Base58EncodedAddress<TFeePayerAddress>,\n transaction: TTransaction | (TTransaction & ITransactionWithFeePayer<string>)\n): TTransaction & ITransactionWithFeePayer<TFeePayerAddress>;\n\nexport function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(\n feePayer: Base58EncodedAddress<TFeePayerAddress>,\n transaction:\n | TTransaction\n | (TTransaction & ITransactionWithFeePayer<string>)\n | (TTransaction & ITransactionWithSignatures)\n | (TTransaction & ITransactionWithFeePayer<string> & ITransactionWithSignatures)\n) {\n if ('feePayer' in transaction && feePayer === transaction.feePayer) {\n return transaction;\n }\n const out = {\n ...getUnsignedTransaction(transaction),\n feePayer,\n };\n Object.freeze(out);\n return out;\n}\n","import { ITransactionWithSignatures } from './signatures';\nimport { BaseTransaction } from './types';\nimport { getUnsignedTransaction } from './unsigned-transaction';\n\nexport function appendTransactionInstruction<TTransaction extends BaseTransaction>(\n instruction: TTransaction['instructions'][number],\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): TTransaction | Omit<TTransaction, keyof ITransactionWithSignatures> {\n const out = {\n ...getUnsignedTransaction(transaction),\n instructions: [...transaction.instructions, instruction],\n };\n Object.freeze(out);\n return out;\n}\n\nexport function prependTransactionInstruction<TTransaction extends BaseTransaction>(\n instruction: TTransaction['instructions'][number],\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): TTransaction | Omit<TTransaction, keyof ITransactionWithSignatures> {\n const out = {\n ...getUnsignedTransaction(transaction),\n instructions: [instruction, ...transaction.instructions],\n };\n Object.freeze(out);\n return out;\n}\n","import { array, bytes, Serializer, shortU16, struct } from '@metaplex-foundation/umi-serializers';\n\nimport { getCompiledTransaction } from '../compile-transaction';\nimport { getCompiledMessageEncoder } from './message';\nimport { getUnimplementedDecoder } from './unimplemented';\n\nconst BASE_CONFIG = {\n description: __DEV__ ? 'The wire format of a Solana transaction' : '',\n fixedSize: null,\n maxSize: null,\n} as const;\n\ntype SerializableTransaction = Parameters<typeof getCompiledTransaction>[0];\n\nfunction serialize(transaction: SerializableTransaction) {\n const compiledTransaction = getCompiledTransaction(transaction);\n return struct([\n [\n 'signatures',\n array(bytes({ size: 64 }), {\n ...(__DEV__ ? { description: 'A compact array of 64-byte, base-64 encoded Ed25519 signatures' } : null),\n size: shortU16(),\n }),\n ],\n ['compiledMessage', getCompiledMessageEncoder()],\n ]).serialize(compiledTransaction);\n}\n\nexport function getTransactionEncoder(): Serializer<SerializableTransaction> {\n return {\n ...BASE_CONFIG,\n deserialize: getUnimplementedDecoder('CompiledMessage'),\n serialize,\n };\n}\n","import { Base58EncodedAddress, getAddressComparator } from '@solana/addresses';\nimport {\n AccountRole,\n IAccountLookupMeta,\n IAccountMeta,\n IInstruction,\n isSignerRole,\n isWritableRole,\n mergeRoles,\n ReadonlyAccount,\n ReadonlyAccountLookup,\n ReadonlySignerAccount,\n WritableAccount,\n WritableAccountLookup,\n WritableSignerAccount,\n} from '@solana/instructions';\n\nexport const enum AddressMapEntryType {\n FEE_PAYER,\n LOOKUP_TABLE,\n STATIC,\n}\n\ntype AddressMap = {\n [address: string]: FeePayerAccountEntry | LookupTableAccountEntry | StaticAccountEntry;\n};\ntype FeePayerAccountEntry = Omit<WritableSignerAccount, 'address'> & {\n [TYPE]: AddressMapEntryType.FEE_PAYER;\n};\ntype LookupTableAccountEntry = Omit<ReadonlyAccountLookup | WritableAccountLookup, 'address'> & {\n [TYPE]: AddressMapEntryType.LOOKUP_TABLE;\n};\nexport type OrderedAccounts = (IAccountMeta | IAccountLookupMeta)[] & { readonly __brand: unique symbol };\ntype StaticAccountEntry = Omit<\n ReadonlyAccount | ReadonlySignerAccount | WritableAccount | WritableSignerAccount,\n 'address'\n> & { [TYPE]: AddressMapEntryType.STATIC };\n\nfunction upsert(\n addressMap: AddressMap,\n address: Base58EncodedAddress,\n update: (\n entry: FeePayerAccountEntry | LookupTableAccountEntry | StaticAccountEntry | Record<never, never>\n ) => AddressMap[Base58EncodedAddress]\n) {\n addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });\n}\n\nconst TYPE = Symbol('AddressMapTypeProperty');\nexport const ADDRESS_MAP_TYPE_PROPERTY: typeof TYPE = TYPE;\n\nexport function getAddressMapFromInstructions(\n feePayer: Base58EncodedAddress,\n instructions: readonly IInstruction[]\n): AddressMap {\n const addressMap: AddressMap = {\n [feePayer]: { [TYPE]: AddressMapEntryType.FEE_PAYER, role: AccountRole.WRITABLE_SIGNER },\n };\n const addressesOfInvokedPrograms = new Set<Base58EncodedAddress>();\n for (const instruction of instructions) {\n upsert(addressMap, instruction.programAddress, entry => {\n addressesOfInvokedPrograms.add(instruction.programAddress);\n if (TYPE in entry) {\n if (isWritableRole(entry.role)) {\n switch (entry[TYPE]) {\n case AddressMapEntryType.FEE_PAYER:\n // TODO: Coded error.\n throw new Error(\n 'This transaction includes an address ' +\n `(\\`${instruction.programAddress}\\`) which is both invoked ` +\n 'and set as the fee payer. Program addresses may not pay fees.'\n );\n default:\n // TODO: Coded error.\n throw new Error(\n 'This transaction includes an address ' +\n `(\\`${instruction.programAddress}\\`) which is both invoked ` +\n 'and marked writable. Program addresses may not be writable.'\n );\n }\n }\n if (entry[TYPE] === AddressMapEntryType.STATIC) {\n return entry;\n }\n }\n return { [TYPE]: AddressMapEntryType.STATIC, role: AccountRole.READONLY };\n });\n let addressComparator: ReturnType<typeof getAddressComparator>;\n if (!instruction.accounts) {\n continue;\n }\n for (const account of instruction.accounts) {\n upsert(addressMap, account.address, entry => {\n const {\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n address: _,\n ...accountMeta\n } = account;\n if (TYPE in entry) {\n switch (entry[TYPE]) {\n case AddressMapEntryType.FEE_PAYER:\n // The fee payer already has the highest rank -- it is by definition\n // writable-signer. Return it, no matter how `account` is configured\n return entry as FeePayerAccountEntry;\n case AddressMapEntryType.LOOKUP_TABLE: {\n const nextRole = mergeRoles(entry.role, accountMeta.role);\n if ('lookupTableAddress' in accountMeta) {\n const shouldReplaceEntry =\n // Consider using the new LOOKUP_TABLE if its address is different...\n entry.lookupTableAddress !== accountMeta.lookupTableAddress &&\n // ...and sorts before the existing one.\n (addressComparator ||= getAddressComparator())(\n accountMeta.lookupTableAddress,\n entry.lookupTableAddress\n ) < 0;\n if (shouldReplaceEntry) {\n return {\n [TYPE]: AddressMapEntryType.LOOKUP_TABLE,\n ...accountMeta,\n role: nextRole,\n } as LookupTableAccountEntry;\n }\n } else if (isSignerRole(accountMeta.role)) {\n // Upgrade this LOOKUP_TABLE entry to a static entry if it must sign.\n return {\n [TYPE]: AddressMapEntryType.STATIC,\n role: nextRole,\n } as StaticAccountEntry;\n }\n if (entry.role !== nextRole) {\n return {\n ...entry,\n role: nextRole,\n } as LookupTableAccountEntry;\n } else {\n return entry as LookupTableAccountEntry;\n }\n }\n case AddressMapEntryType.STATIC: {\n const nextRole = mergeRoles(entry.role, accountMeta.role);\n if (\n // Check to see if this address represents a program that is invoked\n // in this transaction.\n addressesOfInvokedPrograms.has(account.address)\n ) {\n if (isWritableRole(accountMeta.role)) {\n // TODO: Coded error.\n throw new Error(\n 'This transaction includes an address ' +\n `(\\`${account.address}\\`) which is both invoked and ` +\n 'marked writable. Program addresses may not be ' +\n 'writable.'\n );\n }\n if (entry.role !== nextRole) {\n return {\n ...entry,\n role: nextRole,\n } as StaticAccountEntry;\n } else {\n return entry as StaticAccountEntry;\n }\n } else if (\n 'lookupTableAddress' in accountMeta &&\n // Static accounts can be 'upgraded' to lookup table accounts as\n // long as they are not require to sign the transaction.\n !isSignerRole(entry.role)\n ) {\n return {\n ...accountMeta,\n [TYPE]: AddressMapEntryType.LOOKUP_TABLE,\n role: nextRole,\n } as LookupTableAccountEntry;\n } else {\n if (entry.role !== nextRole) {\n // The account's role ranks higher than the current entry's.\n return {\n ...entry,\n role: nextRole,\n } as StaticAccountEntry;\n } else {\n return entry as StaticAccountEntry;\n }\n }\n }\n }\n }\n if ('lookupTableAddress' in accountMeta) {\n return {\n ...accountMeta,\n [TYPE]: AddressMapEntryType.LOOKUP_TABLE,\n };\n } else {\n return {\n ...accountMeta,\n [TYPE]: AddressMapEntryType.STATIC,\n };\n }\n });\n }\n }\n return addressMap;\n}\n\nexport function getOrderedAccountsFromAddressMap(addressMap: AddressMap): OrderedAccounts {\n let addressComparator: ReturnType<typeof getAddressComparator>;\n const orderedAccounts: (IAccountMeta | IAccountLookupMeta)[] = Object.entries(addressMap)\n .sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {\n // STEP 1: Rapid precedence check. Fee payer, then static addresses, then lookups.\n if (leftEntry[TYPE] !== rightEntry[TYPE]) {\n if (leftEntry[TYPE] === AddressMapEntryType.FEE_PAYER) {\n return -1;\n } else if (rightEntry[TYPE] === AddressMapEntryType.FEE_PAYER) {\n return 1;\n } else if (leftEntry[TYPE] === AddressMapEntryType.STATIC) {\n return -1;\n } else if (rightEntry[TYPE] === AddressMapEntryType.STATIC) {\n return 1;\n }\n }\n // STEP 2: Sort by signer-writability.\n const leftIsSigner = isSignerRole(leftEntry.role);\n if (leftIsSigner !== isSignerRole(rightEntry.role)) {\n return leftIsSigner ? -1 : 1;\n }\n const leftIsWritable = isWritableRole(leftEntry.role);\n if (leftIsWritable !== isWritableRole(rightEntry.role)) {\n return leftIsWritable ? -1 : 1;\n }\n // STEP 3: Sort by address.\n addressComparator ||= getAddressComparator();\n if (\n leftEntry[TYPE] === AddressMapEntryType.LOOKUP_TABLE &&\n rightEntry[TYPE] === AddressMapEntryType.LOOKUP_TABLE &&\n leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress\n ) {\n return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);\n } else {\n return addressComparator(leftAddress, rightAddress);\n }\n })\n .map(([address, addressMeta]) => ({\n address: address as Base58EncodedAddress<typeof address>,\n ...addressMeta,\n }));\n return orderedAccounts as unknown as OrderedAccounts;\n}\n","import { Base58EncodedAddress, getAddressComparator } from '@solana/addresses';\nimport { AccountRole } from '@solana/instructions';\n\nimport { OrderedAccounts } from './accounts';\n\ntype AddressTableLookup = Readonly<{\n lookupTableAddress: Base58EncodedAddress;\n readableIndices: readonly number[];\n writableIndices: readonly number[];\n}>;\n\nexport function getCompiledAddressTableLookups(orderedAccounts: OrderedAccounts): AddressTableLookup[] {\n const index: Record<\n Base58EncodedAddress,\n { readonly readableIndices: number[]; readonly writableIndices: number[] }\n > = {};\n for (const account of orderedAccounts) {\n if (!('lookupTableAddress' in account)) {\n continue;\n }\n const entry = (index[account.lookupTableAddress] ||= {\n readableIndices: [],\n writableIndices: [],\n });\n if (account.role === AccountRole.WRITABLE) {\n entry.writableIndices.push(account.addressIndex);\n } else {\n entry.readableIndices.push(account.addressIndex);\n }\n }\n return Object.keys(index)\n .sort(getAddressComparator())\n .map(lookupTableAddress => ({\n lookupTableAddress: lookupTableAddress as Base58EncodedAddress,\n ...index[lookupTableAddress as unknown as Base58EncodedAddress],\n }));\n}\n","import { isSignerRole, isWritableRole } from '@solana/instructions';\n\nimport { OrderedAccounts } from './accounts';\n\ntype MessageHeader = Readonly<{\n numReadonlyNonSignerAccounts: number;\n numReadonlySignerAccounts: number;\n numSignerAccounts: number;\n}>;\n\nexport function getCompiledMessageHeader(orderedAccounts: OrderedAccounts): MessageHeader {\n let numReadonlyNonSignerAccounts = 0;\n let numReadonlySignerAccounts = 0;\n let numSignerAccounts = 0;\n for (const account of orderedAccounts) {\n if ('lookupTableAddress' in account) {\n break;\n }\n const accountIsWritable = isWritableRole(account.role);\n if (isSignerRole(account.role)) {\n numSignerAccounts++;\n if (!accountIsWritable) {\n numReadonlySignerAccounts++;\n }\n } else if (!accountIsWritable) {\n numReadonlyNonSignerAccounts++;\n }\n }\n return {\n numReadonlyNonSignerAccounts,\n numReadonlySignerAccounts,\n numSignerAccounts,\n };\n}\n","import { Base58EncodedAddress } from '@solana/addresses';\nimport { IInstruction } from '@solana/instructions';\n\nimport { OrderedAccounts } from './accounts';\n\ntype CompiledInstruction = Readonly<{\n accountIndices?: number[];\n data?: Uint8Array;\n programAddressIndex: number;\n}>;\n\nfunction getAccountIndex(orderedAccounts: OrderedAccounts) {\n const out: Record<Base58EncodedAddress, number> = {};\n for (const [index, account] of orderedAccounts.entries()) {\n out[account.address] = index;\n }\n return out;\n}\n\nexport function getCompiledInstructions(\n instructions: readonly IInstruction[],\n orderedAccounts: OrderedAccounts\n): CompiledInstruction[] {\n const accountIndex = getAccountIndex(orderedAccounts);\n return instructions.map(({ accounts, data, programAddress }) => {\n return {\n programAddressIndex: accountIndex[programAddress],\n ...(accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null),\n ...(data ? { data } : null),\n };\n });\n}\n","import { IDurableNonceTransaction, ITransactionWithBlockhashLifetime } from './index';\n\nexport function getCompiledLifetimeToken(\n lifetimeConstraint: (ITransactionWithBlockhashLifetime | IDurableNonceTransaction)['lifetimeConstraint']\n): string {\n if ('nonce' in lifetimeConstraint) {\n return lifetimeConstraint.nonce;\n }\n return lifetimeConstraint.blockhash;\n}\n","import { Base58EncodedAddress } from '@solana/addresses';\n\nimport { OrderedAccounts } from './accounts';\n\nexport function getCompiledStaticAccounts(orderedAccounts: OrderedAccounts): Base58EncodedAddress[] {\n const firstLookupTableAccountIndex = orderedAccounts.findIndex(account => 'lookupTableAddress' in account);\n const orderedStaticAccounts =\n firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);\n return orderedStaticAccounts.map(({ address }) => address);\n}\n","import { getAddressMapFromInstructions, getOrderedAccountsFromAddressMap } from './accounts';\nimport { ITransactionWithBlockhashLifetime } from './blockhash';\nimport { getCompiledAddressTableLookups } from './compile-address-table-lookups';\nimport { getCompiledMessageHeader } from './compile-header';\nimport { getCompiledInstructions } from './compile-instructions';\nimport { getCompiledLifetimeToken } from './compile-lifetime-token';\nimport { getCompiledStaticAccounts } from './compile-static-accounts';\nimport { IDurableNonceTransaction } from './durable-nonce';\nimport { ITransactionWithFeePayer } from './fee-payer';\nimport { BaseTransaction } from './types';\n\ntype BaseCompiledMessage = Readonly<{\n header: ReturnType<typeof getCompiledMessageHeader>;\n instructions: ReturnType<typeof getCompiledInstructions>;\n lifetimeToken: ReturnType<typeof getCompiledLifetimeToken>;\n staticAccounts: ReturnType<typeof getCompiledStaticAccounts>;\n}>;\n\ntype CompilableTransaction = BaseTransaction &\n ITransactionWithFeePayer &\n (ITransactionWithBlockhashLifetime | IDurableNonceTransaction);\n\nexport type CompiledMessage = LegacyCompiledMessage | VersionedCompiledMessage;\n\ntype LegacyCompiledMessage = BaseCompiledMessage &\n Readonly<{\n version: 'legacy';\n }>;\n\ntype VersionedCompiledMessage = BaseCompiledMessage &\n Readonly<{\n addressTableLookups?: ReturnType<typeof getCompiledAddressTableLookups>;\n version: number;\n }>;\n\nexport function compileMessage(\n transaction: CompilableTransaction & Readonly<{ version: 'legacy' }>\n): LegacyCompiledMessage;\nexport function compileMessage(transaction: CompilableTransaction): VersionedCompiledMessage;\nexport function compileMessage(transaction: CompilableTransaction): CompiledMessage {\n const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);\n const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);\n return {\n ...(transaction.version !== 'legacy'\n ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) }\n : null),\n header: getCompiledMessageHeader(orderedAccounts),\n instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),\n lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),\n staticAccounts: getCompiledStaticAccounts(orderedAccounts),\n version: transaction.version,\n };\n}\n","import { Ed25519Signature } from '@solana/keys';\n\nimport { CompiledMessage, compileMessage } from './message';\nimport { ITransactionWithSignatures } from './signatures';\n\ntype CompiledTransaction = Readonly<{\n compiledMessage: CompiledMessage;\n signatures: Ed25519Signature[];\n}>;\n\ntype CompilableTransaction = Parameters<typeof compileMessage>[0];\n\nexport function getCompiledTransaction(\n transaction: CompilableTransaction | (CompilableTransaction & ITransactionWithSignatures)\n): CompiledTransaction {\n const compiledMessage = compileMessage(transaction);\n let signatures;\n if ('signatures' in transaction) {\n signatures = [];\n for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {\n signatures[ii] =\n transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));\n }\n } else {\n signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));\n }\n return {\n compiledMessage,\n signatures,\n };\n}\n","import {\n array,\n base58,\n mapSerializer,\n Serializer,\n shortU16,\n string,\n struct,\n StructToSerializerTuple,\n} from '@metaplex-foundation/umi-serializers';\nimport { getAddressCodec } from '@solana/addresses';\nimport { Codec } from '@solana/codecs-core';\n\nimport { CompiledMessage } from '../message';\nimport { SerializedMessageBytes } from '../types';\nimport { getAddressTableLookupCodec } from './address-table-lookup';\nimport { getMessageHeaderCodec } from './header';\nimport { getInstructionCodec } from './instruction';\nimport { getTransactionVersionCodec } from './transaction-version';\nimport { getUnimplementedDecoder, getUnimplementedEncoder } from './unimplemented';\n\nconst BASE_CONFIG = {\n description: __DEV__ ? 'The wire format of a Solana transaction message' : '',\n fixedSize: null,\n maxSize: null,\n} as const;\n\nfunction deserialize(bytes: Uint8Array, offset = 0): [CompiledMessage, number] {\n const preludeAndOffset = struct(getPreludeStructSerializerTuple()).deserialize(bytes, offset);\n const [prelude, endOfPreludeOffset] = preludeAndOffset;\n if (prelude.version === 'legacy') {\n return preludeAndOffset;\n }\n const [addressTableLookups, finalOffset] = getAddressTableLookupsSerializer().deserialize(\n bytes,\n endOfPreludeOffset\n );\n return [\n {\n ...prelude,\n ...(addressTableLookups.length ? { addressTableLookups } : null),\n },\n finalOffset,\n ];\n}\n\nfunction serialize(compiledMessage: CompiledMessage): SerializedMessageBytes {\n if (compiledMessage.version === 'legacy') {\n return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage) as SerializedMessageBytes;\n } else {\n return mapSerializer(\n struct([\n ...getPreludeStructSerializerTuple(),\n ['addressTableLookups', getAddressTableLookupsSerializer()],\n ] as StructToSerializerTuple<CompiledMessage, CompiledMessage>),\n (value: CompiledMessage) => {\n if (value.version === 'legacy') {\n return value;\n }\n return {\n ...value,\n addressTableLookups: value.addressTableLookups ?? [],\n } as Exclude<CompiledMessage, { readonly version: 'legacy' }>;\n }\n ).serialize(compiledMessage) as SerializedMessageBytes;\n }\n}\n\n// Temporary, convert a codec to a serializer for compatiblity for now\nfunction toSerializer<T>(codec: Codec<T>): Serializer<T> {\n return {\n description: codec.description,\n deserialize: codec.decode,\n fixedSize: codec.fixedSize,\n maxSize: codec.maxSize,\n serialize: codec.encode,\n };\n}\n\nfunction getPreludeStructSerializerTuple(): StructToSerializerTuple<CompiledMessage, CompiledMessage> {\n return [\n ['version', toSerializer(getTransactionVersionCodec())],\n ['header', toSerializer(getMessageHeaderCodec())],\n [\n 'staticAccounts',\n array(toSerializer(getAddressCodec()), {\n description: __DEV__ ? 'A compact-array of static account addresses belonging to this transaction' : '',\n size: shortU16(),\n }),\n ],\n [\n 'lifetimeToken',\n string({\n description: __DEV__\n ? 'A 32-byte token that specifies the lifetime of this transaction (eg. a ' +\n 'recent blockhash, or a durable nonce)'\n : '',\n encoding: base58,\n size: 32,\n }),\n ],\n [\n 'instructions',\n array(getInstructionCodec(), {\n description: __DEV__ ? 'A compact-array of instructions belonging to this transaction' : '',\n size: shortU16(),\n }),\n ],\n ];\n}\n\nfunction getAddressTableLookupsSerializer() {\n return array(getAddressTableLookupCodec(), {\n ...(__DEV__ ? { description: 'A compact array of address table lookups belonging to this transaction' } : null),\n size: shortU16(),\n });\n}\n\nexport function getCompiledMessageEncoder(): Serializer<CompiledMessage> {\n return {\n ...BASE_CONFIG,\n deserialize: getUnimplementedDecoder('CompiledMessage'),\n serialize,\n };\n}\n\nexport function getCompiledMessageDecoder(): Serializer<CompiledMessage> {\n return {\n ...BASE_CONFIG,\n deserialize,\n serialize: getUnimplementedEncoder('CompiledMessage'),\n };\n}\n\nexport function getCompiledMessageCodec(): Serializer<CompiledMessage> {\n return {\n ...BASE_CONFIG,\n deserialize,\n serialize,\n };\n}\n","import { array, Serializer, shortU16, struct, StructToSerializerTuple, u8 } from '@metaplex-foundation/umi-serializers';\nimport { Base58EncodedAddress, getAddressCodec } from '@solana/addresses';\n\nimport { getCompiledAddressTableLookups } from '../compile-address-table-lookups';\n\ntype AddressTableLookup = ReturnType<typeof getCompiledAddressTableLookups>[number];\n\n// Temporary, will use getAddressCodec directly when everything else is migrated\nfunction addressSerializerCompat(compat?: { description: string }): Serializer<Base58EncodedAddress> {\n const codec = getAddressCodec();\n return {\n description: compat?.description ?? codec.description,\n deserialize: codec.decode,\n fixedSize: codec.fixedSize,\n maxSize: codec.maxSize,\n serialize: codec.encode,\n };\n}\n\nexport function getAddressTableLookupCodec(): Serializer<AddressTableLookup> {\n return struct(\n [\n [\n 'lookupTableAddress',\n addressSerializerCompat(\n __DEV__\n ? {\n description:\n 'The address of the address lookup table account from which ' +\n 'instruction addresses should be looked up',\n }\n : undefined\n ),\n ],\n [\n 'writableIndices',\n array(u8(), {\n ...(__DEV__\n ? {\n description:\n 'The indices of the accounts in the lookup table that should ' +\n 'be loaded as writeable',\n }\n : null),\n size: shortU16(),\n }),\n ],\n [\n 'readableIndices',\n array(u8(), {\n ...(__DEV__\n ? {\n description:\n 'The indices of the accounts in the lookup table that should ' +\n 'be loaded as read-only',\n }\n : undefined),\n size: shortU16(),\n }),\n ],\n ] as StructToSerializerTuple<AddressTableLookup, AddressTableLookup>,\n __DEV__\n ? {\n description:\n 'A pointer to the address of an address lookup table, along with the ' +\n 'readonly/writeable indices of the addresses that should be loaded from it',\n }\n : undefined\n );\n}\n","import { Codec, Decoder, Encoder } from '@solana/codecs-core';\nimport { getStructCodec, getStructDecoder, getStructEncoder } from '@solana/codecs-data-structures';\nimport { getU8Codec, getU8Decoder, getU8Encoder } from '@solana/codecs-numbers';\n\nimport { getCompiledMessageHeader } from '../compile-header';\n\ntype MessageHeader = ReturnType<typeof getCompiledMessageHeader>;\n\nlet memoizedU8Encoder: Encoder<number> | undefined;\nfunction getMemoizedU8Encoder(): Encoder<number> {\n if (!memoizedU8Encoder) memoizedU8Encoder = getU8Encoder();\n return memoizedU8Encoder;\n}\n\nfunction getMemoizedU8EncoderDescription(description?: string): Encoder<number> {\n const encoder = getMemoizedU8Encoder();\n return {\n ...encoder,\n description: description ?? encoder.description,\n };\n}\n\nlet memoizedU8Decoder: Decoder<number> | undefined;\nfunction getMemoizedU8Decoder(): Decoder<number> {\n if (!memoizedU8Decoder) memoizedU8Decoder = getU8Decoder();\n return memoizedU8Decoder;\n}\n\nfunction getMemoizedU8DecoderDescription(description?: string): Decoder<number> {\n const decoder = getMemoizedU8Decoder();\n return {\n ...decoder,\n description: description ?? decoder.description,\n };\n}\n\nlet memoizedU8Codec: Codec<number> | undefined;\nfunction getMemoizedU8Codec(): Codec<number> {\n if (!memoizedU8Codec) memoizedU8Codec = getU8Codec();\n return memoizedU8Codec;\n}\n\nfunction getMemoizedU8CodecDescription(description?: string): Codec<number> {\n const codec = getMemoizedU8Codec();\n return {\n ...codec,\n description: description ?? codec.description,\n };\n}\n\nconst numSignerAccountsDescription = __DEV__\n ? 'The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction'\n : undefined;\n\nconst numReadonlySignerAccountsDescription = __DEV__\n ? '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'\n : undefined;\n\nconst numReadonlyNonSignerAccountsDescription = __DEV__\n ? 'The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable'\n : undefined;\n\nconst messageHeaderDescription = __DEV__\n ? 'The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses'\n : undefined;\n\nexport function getMessageHeaderEncoder(): Encoder<MessageHeader> {\n return getStructEncoder(\n [\n ['numSignerAccounts', getMemoizedU8EncoderDescription(numSignerAccountsDescription)],\n ['numReadonlySignerAccounts', getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],\n ['numReadonlyNonSignerAccounts', getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)],\n ],\n {\n description: messageHeaderDescription,\n }\n );\n}\n\nexport function getMessageHeaderDecoder(): Decoder<MessageHeader> {\n return getStructDecoder(\n [\n ['numSignerAccounts', getMemoizedU8DecoderDescription(numSignerAccountsDescription)],\n ['numReadonlySignerAccounts', getMemoizedU8DecoderDescription(numReadonlySignerAccountsDescription)],\n ['numReadonlyNonSignerAccounts', getMemoizedU8DecoderDescription(numReadonlyNonSignerAccountsDescription)],\n ],\n {\n description: messageHeaderDescription,\n }\n );\n}\n\nexport function getMessageHeaderCodec(): Codec<MessageHeader> {\n return getStructCodec(\n [\n ['numSignerAccounts', getMemoizedU8CodecDescription(numSignerAccountsDescription)],\n ['numReadonlySignerAccounts', getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],\n ['numReadonlyNonSignerAccounts', getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)],\n ],\n {\n description: messageHeaderDescription,\n }\n );\n}\n","import { array, bytes, mapSerializer, Serializer, shortU16, struct, u8 } from '@metaplex-foundation/umi-serializers';\n\nimport { getCompiledInstructions } from '../compile-instructions';\n\ntype Instruction = ReturnType<typeof getCompiledInstructions>[number];\n\nexport function getInstructionCodec(): Serializer<Instruction> {\n return mapSerializer<Instruction, Required<Instruction>>(\n struct([\n [\n 'programAddressIndex',\n u8(\n __DEV__\n ? {\n description:\n 'The index of the program being called, according to the ' +\n 'well-ordered accounts list for this transaction',\n }\n : undefined\n ),\n ],\n [\n 'accountIndices',\n array(\n u8({\n description: __DEV__\n ? 'The index of an account, according to the well-ordered accounts ' +\n 'list for this transaction'\n : '',\n }),\n {\n description: __DEV__\n ? 'An optional list of account indices, according to the ' +\n 'well-ordered accounts list for this transaction, in the order in ' +\n 'which the program being called expects them'\n : '',\n size: shortU16(),\n }\n ),\n ],\n [\n 'data',\n bytes({\n description: __DEV__ ? 'An optional buffer of data passed to the instruction' : '',\n size: shortU16(),\n }),\n ],\n ]),\n (value: Instruction) => {\n if (value.accountIndices !== undefined && value.data !== undefined) {\n return value as Required<Instruction>;\n }\n return {\n ...value,\n accountIndices: value.accountIndices ?? [],\n data: value.data ?? new Uint8Array(0),\n } as Required<Instruction>;\n },\n (value: Required<Instruction>) => {\n if (value.accountIndices.length && value.data.byteLength) {\n return value;\n }\n const { accountIndices, data, ...rest } = value;\n return {\n ...rest,\n ...(accountIndices.length ? { accountIndices } : null),\n ...(data.byteLength ? { data } : null),\n };\n }\n );\n}\n","import { Codec, combineCodec, Decoder, Encoder } from '@solana/codecs-core';\n\nimport { TransactionVersion } from '../types';\n\nconst VERSION_FLAG_MASK = 0x80;\n\nconst BASE_CONFIG = {\n description: __DEV__ ? 'A single byte that encodes the version of the transaction' : '',\n fixedSize: null,\n maxSize: 1,\n} as const;\n\nfunction decode(bytes: Uint8Array, offset = 0): [TransactionVersion, number] {\n const firstByte = bytes[offset];\n if ((firstByte & VERSION_FLAG_MASK) === 0) {\n // No version flag set; it's a legacy (unversioned) transaction.\n return ['legacy', offset];\n } else {\n const version = (firstByte ^ VERSION_FLAG_MASK) as TransactionVersion;\n return [version, offset + 1];\n }\n}\n\nfunction encode(value: TransactionVersion): Uint8Array {\n if (value === 'legacy') {\n return new Uint8Array();\n }\n if (value < 0 || value > 127) {\n // TODO: Coded error.\n throw new Error(`Transaction version must be in the range [0, 127]. \\`${value}\\` given.`);\n }\n return new Uint8Array([value | VERSION_FLAG_MASK]);\n}\n\nexport function getTransactionVersionDecoder(): Decoder<TransactionVersion> {\n return {\n ...BASE_CONFIG,\n decode,\n };\n}\n\nexport function getTransactionVersionEncoder(): Encoder<TransactionVersion> {\n return {\n ...BASE_CONFIG,\n encode,\n };\n}\n\nexport function getTransactionVersionCodec(): Codec<TransactionVersion> {\n return combineCodec(getTransactionVersionEncoder(), getTransactionVersionDecoder());\n}\n","function getError(type: 'decoder' | 'encoder', name: string) {\n const functionSuffix = name + type[0].toUpperCase() + type.slice(1);\n return new Error(\n `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}`\n );\n}\n\nexport function getUnimplementedDecoder(name: string): () => never {\n return () => {\n throw getError('decoder', name);\n };\n}\n\nexport function getUnimplementedEncoder(name: string): () => never {\n return () => {\n throw getError('encoder', name);\n };\n}\n","import { base58 } from '@metaplex-foundation/umi-serializers';\nimport { Base58EncodedAddress, getAddressFromPublicKey } from '@solana/addresses';\nimport { Ed25519Signature, signBytes } from '@solana/keys';\n\nimport { ITransactionWithFeePayer } from './fee-payer';\nimport { CompiledMessage, compileMessage } from './message';\nimport { getCompiledMessageEncoder } from './serializers/message';\n\nexport interface IFullySignedTransaction extends ITransactionWithSignatures {\n readonly __brand: unique symbol;\n}\nexport interface ITransactionWithSignatures {\n readonly signatures: Readonly<Record<Base58EncodedAddress, Ed25519Signature>>;\n}\n\nexport type TransactionSignature = string & { readonly __brand: unique symbol };\n\nexport function assertIsTransactionSignature(\n putativeTransactionSignature: string\n): asserts putativeTransactionSignature is TransactionSignature {\n try {\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest value (64 bytes of zeroes)\n putativeTransactionSignature.length < 64 ||\n // Highest value (64 bytes of 255)\n putativeTransactionSignature.length > 88\n ) {\n throw new Error('Expected input string to decode to a byte array of length 64.');\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base58.serialize(putativeTransactionSignature);\n const numBytes = bytes.byteLength;\n if (numBytes !== 64) {\n throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);\n }\n } catch (e) {\n throw new Error(`\\`${putativeTransactionSignature}\\` is not a transaction signature`, {\n cause: e,\n });\n }\n}\n\nexport function isTransactionSignature(\n putativeTransactionSignature: string\n): putativeTransactionSignature is TransactionSignature {\n // Fast-path; see if the input string is of an acceptable length.\n if (\n // Lowest value (64 bytes of zeroes)\n putativeTransactionSignature.length < 64 ||\n // Highest value (64 bytes of 255)\n putativeTransactionSignature.length > 88\n ) {\n return false;\n }\n // Slow-path; actually attempt to decode the input string.\n const bytes = base58.serialize(putativeTransactionSignature);\n const numBytes = bytes.byteLength;\n if (numBytes !== 64) {\n return false;\n }\n return true;\n}\n\nasync function getCompiledMessageSignature(message: CompiledMessage, secretKey: CryptoKey) {\n const wireMessageBytes = getCompiledMessageEncoder().serialize(message);\n const signature = await signBytes(secretKey, wireMessageBytes);\n return signature;\n}\n\nexport function getSignatureFromTransaction(\n transaction: ITransactionWithFeePayer & ITransactionWithSignatures\n): TransactionSignature {\n const signature = transaction.signatures[transaction.feePayer];\n if (!signature) {\n // TODO: Coded error.\n throw new Error(\n \"Could not determine this transaction's signature. Make sure that the transaction \" +\n 'has been signed by its fee payer.'\n );\n }\n return signature as unknown as TransactionSignature;\n}\n\nexport async function signTransaction<TTransaction extends Parameters<typeof compileMessage>[0]>(\n keyPairs: CryptoKeyPair[],\n transaction: TTransaction | (TTransaction & ITransactionWithSignatures)\n): Promise<TTransaction & ITransactionWithSignatures> {\n const compiledMessage = compileMessage(transaction);\n const nextSignatures: Record<Base58EncodedAddress, Ed25519Signature> =\n 'signatures' in transaction ? { ...transaction.signatures } : {};\n const publicKeySignaturePairs = await Promise.all(\n keyPairs.map(keyPair =>\n Promise.all([\n getAddressFromPublicKey(keyPair.publicKey),\n getCompiledMessageSignature(compiledMessage, keyPair.privateKey),\n ])\n )\n );\n for (const [signerPublicKey, signature] of publicKeySignaturePairs) {\n nextSignatures[signerPublicKey] = signature;\n }\n const out = {\n ...transaction,\n signatures: nextSignatures,\n };\n Object.freeze(out);\n return out;\n}\n\nexport function transactionSignature(putativeTransactionSignature: string): TransactionSignature {\n assertIsTransactionSignature(putativeTransactionSignature);\n return putativeTransactionSignature;\n}\n","import { getTransactionEncoder } from './serializers/transaction';\n\nexport type Base64EncodedWireTransaction = string & {\n readonly __brand: unique symbol;\n};\n\nexport function getBase64EncodedWireTransaction(\n transaction: Parameters<ReturnType<typeof getTransactionEncoder>['serialize']>[0]\n): Base64EncodedWireTransaction {\n const wireTransactionBytes = getTransactionEncoder().serialize(transaction);\n if (__NODEJS__) {\n return Buffer.from(wireTransactionBytes).toString('base64') as Base64EncodedWireTransaction;\n } else {\n return (btoa as Window['btoa'])(String.fromCharCode(...wireTransactionBytes)) as Base64EncodedWireTransaction;\n }\n}\n"]}
package/dist/index.production.min.js CHANGED
@@ -2,12 +2,23 @@ this.globalThis = this.globalThis || {};
2
2
  this.globalThis.solanaWeb3 = (function (exports) {
3
3
  'use strict';
4
4
 
5
- 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}
5
+ var dr=Object.defineProperty;var ur=(e,r,n)=>r in e?dr(e,r,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[r]=n;var y=(e,r,n)=>(ur(e,typeof r!="symbol"?r+"":r,n),n);var S=e=>{let r=e.reduce((o,i)=>o+i.length,0),n=new Uint8Array(r),t=0;return e.forEach(o=>{n.set(o,t),t+=o.length;}),n},le=(e,r)=>{if(e.length>=r)return e;let n=new Uint8Array(r).fill(0);return n.set(e),n},L=(e,r)=>le(e.slice(0,r),r);var b=class extends Error{constructor(n){super(`Serializer [${n}] cannot deserialize empty buffers.`);y(this,"name","DeserializingEmptyBufferError");}},x=class extends Error{constructor(n,t,o){super(`Serializer [${n}] expected ${t} bytes, got ${o}.`);y(this,"name","NotEnoughBytesError");}},I=class extends Error{constructor(n){n??(n="Expected a fixed-size serializer, got a variable-size one.");super(n);y(this,"name","ExpectedFixedSizeSerializerError");}};function _(e,r,n){return {description:n??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r,serialize:t=>L(e.serialize(t),r),deserialize:(t,o=0)=>{if(t=t.slice(o,o+r),t.length<r)throw new x("fixSerializer",r,t.length);e.fixedSize!==null&&(t=L(t,e.fixedSize));let[i]=e.deserialize(t,0);return [i,o+r]}}}function k(e,r,n){return {description:e.description,fixedSize:e.fixedSize,maxSize:e.maxSize,serialize:t=>e.serialize(r(t)),deserialize:(t,o=0)=>{let[i,s]=e.deserialize(t,o);return n?[n(i,t,o),s]:[i,s]}}}var M=class extends Error{constructor(n,t,o){let i=`Expected a string of base ${t}, got [${n}].`;super(i);y(this,"name","InvalidBaseStringError");this.cause=o;}};var fe=e=>{let r=e.length,n=BigInt(r);return {description:`base${r}`,fixedSize:null,maxSize:null,serialize(t){if(!t.match(new RegExp(`^[${e}]*$`)))throw new M(t,r);if(t==="")return new Uint8Array;let o=[...t],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),u=0n,d=1n;for(let f=c.length-1;f>=0;f-=1)u+=d*BigInt(e.indexOf(c[f])),d*=n;let l=[];for(;u>0n;)l.unshift(Number(u%256n)),u/=256n;return Uint8Array.from(s.concat(l))},deserialize(t,o=0){if(t.length===0)return ["",0];let i=t.slice(o),s=i.findIndex(l=>l!==0);s=s===-1?i.length:s;let c=e[0].repeat(s);if(s===i.length)return [c,t.length];let u=i.slice(s).reduce((l,f)=>l*256n+BigInt(f),0n),d=[];for(;u>0n;)d.unshift(e[Number(u%n)]),u/=n;return [c+d.join(""),t.length]}}};var E=fe("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");var me=e=>e.replace(/\u0000/g,"");var Z={description:"utf8",fixedSize:null,maxSize:null,serialize(e){return new TextEncoder().encode(e)},deserialize(e,r=0){let n=new TextDecoder().decode(e.slice(r));return [me(n),e.length]}};var P;(function(e){e.Little="le",e.Big="be";})(P||(P={}));var V=class extends RangeError{constructor(n,t,o,i){super(`Serializer [${n}] expected number to be between ${t} and ${o}, got ${i}.`);y(this,"name","NumberOutOfRangeError");}};function F(e){let r,n=e.name;return e.size>1&&(r=!("endian"in e.options)||e.options.endian===P.Little,n+=r?"(le)":"(be)"),{description:e.options.description??n,fixedSize:e.size,maxSize:e.size,serialize(t){e.range&&J(e.name,e.range[0],e.range[1],t);let o=new ArrayBuffer(e.size);return e.set(new DataView(o),t,r),new Uint8Array(o)},deserialize(t,o=0){let i=t.slice(o,o+e.size);mr("i8",i,e.size);let s=fr(i);return [e.get(s,r),o+e.size]}}}var lr=e=>e.buffer.slice(e.byteOffset,e.byteLength+e.byteOffset),fr=e=>new DataView(lr(e)),J=(e,r,n,t)=>{if(t<r||t>n)throw new V(e,r,n,t)},mr=(e,r,n)=>{if(r.length===0)throw new b(e);if(r.length<n)throw new x(e,n,r.length)};var w=(e={})=>F({name:"u8",size:1,range:[0,+"0xff"],set:(r,n)=>r.setUint8(0,Number(n)),get:r=>r.getUint8(0),options:e});var R=(e={})=>F({name:"u32",size:4,range:[0,+"0xffffffff"],set:(r,n,t)=>r.setUint32(0,Number(n),t),get:(r,n)=>r.getUint32(0,n),options:e});var p=(e={})=>({description:e.description??"shortU16",fixedSize:null,maxSize:3,serialize:r=>{J("shortU16",0,65535,r);let n=[0];for(let t=0;;t+=1){let o=r>>t*7;if(o===0)break;let i=127&o;n[t]=i,t>0&&(n[t-1]|=128);}return new Uint8Array(n)},deserialize:(r,n=0)=>{let t=0,o=0;for(;++o;){let i=o-1,s=r[n+i],c=127&s;if(t|=c<<i*7,!(s&128))break}return [t,n+o]}});var W=class extends Error{constructor(n,t,o){super(`Expected [${n}] to have ${t} items, got ${o}.`);y(this,"name","InvalidNumberOfItemsError");}},H=class extends Error{constructor(n,t){super(`The remainder of the buffer (${n} bytes) cannot be split into chunks of ${t} bytes. Serializers of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${n} modulo ${t} should be equal to zero.`);y(this,"name","InvalidArrayLikeRemainderSizeError");}},j=class extends Error{constructor(n){super(`Unrecognized array-like serializer size: ${JSON.stringify(n)}`);y(this,"name","UnrecognizedArrayLikeSerializerSizeError");}};function v(e){return e.reduce((r,n)=>r===null||n===null?null:r+n,0)}function ge(e,r,n,t){if(typeof e=="number")return [e,t];if(typeof e=="object")return e.deserialize(n,t);if(e==="remainder"){let o=v(r);if(o===null)throw new I('Serializers of "remainder" size must have fixed-size items.');let i=n.slice(t).length;if(i%o!==0)throw new H(i,o);return [i/o,t]}throw new j(e)}function D(e){return typeof e=="object"?e.description:`${e}`}function Q(e,r){if(typeof e!="number")return null;if(e===0)return 0;let n=v(r);return n===null?null:n*e}function pe(e,r){return typeof e=="object"?e.serialize(r):new Uint8Array}function h(e,r={}){let n=r.size??R();if(n==="remainder"&&e.fixedSize===null)throw new I('Serializers of "remainder" size must have fixed-size items.');return {description:r.description??`array(${e.description}; ${D(n)})`,fixedSize:Q(n,[e.fixedSize]),maxSize:Q(n,[e.maxSize]),serialize:t=>{if(typeof n=="number"&&t.length!==n)throw new W("array",n,t.length);return S([pe(n,t.length),...t.map(o=>e.serialize(o))])},deserialize:(t,o=0)=>{if(typeof n=="object"&&t.slice(o).length===0)return [[],o];let[i,s]=ge(n,[e.fixedSize],t,o);o=s;let c=[];for(let u=0;u<i;u+=1){let[d,l]=e.deserialize(t,o);c.push(d),o=l;}return [c,o]}}}function U(e={}){let r=e.size??"variable",n=e.description??`bytes(${D(r)})`,t={description:n,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"?t:typeof r=="number"?_(t,r,n):{description:n,fixedSize:null,maxSize:null,serialize:o=>{let i=t.serialize(o),s=r.serialize(i.length);return S([s,i])},deserialize:(o,i=0)=>{if(o.slice(i).length===0)throw new b("bytes");let[s,c]=r.deserialize(o,i),u=Number(s);i=c;let d=o.slice(i,i+u);if(d.length<u)throw new x("bytes",u,d.length);let[l,f]=t.deserialize(d);return i+=f,[l,i]}}}function ee(e={}){let r=e.size??R(),n=e.encoding??Z,t=e.description??`string(${n.description}; ${D(r)})`;return r==="variable"?{...n,description:t}:typeof r=="number"?_(n,r,t):{description:t,fixedSize:null,maxSize:null,serialize:o=>{let i=n.serialize(o),s=r.serialize(i.length);return S([s,i])},deserialize:(o,i=0)=>{if(o.slice(i).length===0)throw new b("string");let[s,c]=r.deserialize(o,i),u=Number(s);i=c;let d=o.slice(i,i+u);if(d.length<u)throw new x("string",u,d.length);let[l,f]=n.deserialize(d);return i+=f,[l,i]}}}function T(e,r={}){let n=e.map(([t,o])=>`${String(t)}: ${o.description}`).join(", ");return {description:r.description??`struct(${n})`,fixedSize:v(e.map(([,t])=>t.fixedSize)),maxSize:v(e.map(([,t])=>t.maxSize)),serialize:t=>{let o=e.map(([i,s])=>s.serialize(t[i]));return S(o)},deserialize:(t,o=0)=>{let i={};return e.forEach(([s,c])=>{let[u,d]=c.deserialize(t,o);o=d,i[s]=u;}),[i,o]}}}function A(e){if("signatures"in e){let{signatures:r,...n}=e;return n}else return e}function qt(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 n=E.serialize(e).byteLength;if(n!==32)throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${n}`)}catch(r){throw new Error(`\`${e}\` is not a blockhash`,{cause:r})}}function Xt(e,r){if("lifetimeConstraint"in r&&r.lifetimeConstraint.blockhash===e.blockhash&&r.lifetimeConstraint.lastValidBlockHeight===e.lastValidBlockHeight)return r;let n={...A(r),lifetimeConstraint:e};return Object.freeze(n),n}function Qt({version:e}){let r={instructions:[],version:e};return Object.freeze(r),r}var g=(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))(g||{});var gr=1;function B(e){return e>=2}function C(e){return (e&gr)!==0}function re(e,r){return e|r}var ye="SysvarRecentB1ockHashes11111111111111111111",he="11111111111111111111111111111111";function uo(e){if(!xe(e))throw new Error("Transaction is not a durable nonce transaction")}function pr(e,r){return {accounts:[{address:e,role:g.WRITABLE},{address:ye,role:g.READONLY},{address:r,role:g.READONLY_SIGNER}],data:new Uint8Array([4,0,0,0]),programAddress:he}}function yr(e){return e.programAddress===he&&e.data!=null&&hr(e.data)&&e.accounts?.length===3&&e.accounts[0].address!=null&&e.accounts[0].role===g.WRITABLE&&e.accounts[1].address===ye&&e.accounts[1].role===g.READONLY&&e.accounts[2].address!=null&&e.accounts[2].role===g.READONLY_SIGNER}function hr(e){return e.byteLength===4&&e[0]===4&&e[1]===0&&e[2]===0&&e[3]===0}function xe(e){return "lifetimeConstraint"in e&&typeof e.lifetimeConstraint.nonce=="string"&&e.instructions[0]!=null&&yr(e.instructions[0])}function lo({nonce:e,nonceAccountAddress:r,nonceAuthorityAddress:n},t){let o=xe(t);if(o&&t.lifetimeConstraint.nonce===e&&t.instructions[0].accounts[0].address===r&&t.instructions[0].accounts[2].address===n)return t;let i={...A(t),instructions:[pr(r,n),...o?t.instructions.slice(1):t.instructions],lifetimeConstraint:{nonce:e}};return Object.freeze(i),i}function po(e,r){if("feePayer"in r&&e===r.feePayer)return r;let n={...A(r),feePayer:e};return Object.freeze(n),n}function To(e,r){let n={...A(r),instructions:[...r.instructions,e]};return Object.freeze(n),n}function So(e,r){let n={...A(r),instructions:[e,...r.instructions]};return Object.freeze(n),n}function $(e,r,n=0){if(r.length-n<=0)throw new Error(`Codec [${e}] cannot decode empty byte arrays.`)}function N(e,r,n,t=0){let o=n.length-t;if(o<r)throw new Error(`Codec [${e}] expected ${r} bytes, got ${o}.`)}var K=e=>{let r=e.filter(i=>i.length);if(r.length===0)return e.length?e[0]:new Uint8Array;if(r.length===1)return r[0];let n=r.reduce((i,s)=>i+s.length,0),t=new Uint8Array(n),o=0;return r.forEach(i=>{t.set(i,o),o+=i.length;}),t},xr=(e,r)=>{if(e.length>=r)return e;let n=new Uint8Array(r).fill(0);return n.set(e),n},ne=(e,r)=>xr(e.length<=r?e:e.slice(0,r),r);function z(e,r,n){if(e.fixedSize!==r.fixedSize)throw new Error(`Encoder and decoder must have the same fixed size, got [${e.fixedSize}] and [${r.fixedSize}].`);if(e.maxSize!==r.maxSize)throw new Error(`Encoder and decoder must have the same max size, got [${e.maxSize}] and [${r.maxSize}].`);if(n===void 0&&e.description!==r.description)throw new Error(`Encoder and decoder must have the same description, got [${e.description}] and [${r.description}]. Pass a custom description as a third argument if you want to override the description and bypass this error.`);return {decode:r.decode,description:n??e.description,encode:e.encode,fixedSize:e.fixedSize,maxSize:e.maxSize}}function Te(e,r,n){return {description:n??`fixed(${r}, ${e.description})`,fixedSize:r,maxSize:r}}function te(e,r,n){return {...Te(e,r,n),encode:t=>ne(e.encode(t),r)}}function oe(e,r,n){return {...Te(e,r,n),decode:(t,o=0)=>{N("fixCodec",r,t,o),(o>0||t.length>r)&&(t=t.slice(o,o+r)),e.fixedSize!==null&&(t=ne(t,e.fixedSize));let[i]=e.decode(t,0);return [i,o+r]}}}function Se(e,r){return {description:e.description,encode:n=>e.encode(r(n)),fixedSize:e.fixedSize,maxSize:e.maxSize}}function Tr(e,r,n,t){if(t<r||t>n)throw new Error(`Codec [${e}] expected number to be in the range [${r}, ${n}], got ${t}.`)}function be(e){let r,n=e.name;return e.size>1&&(r=!("endian"in e.options)||e.options.endian===0,n+=r?"(le)":"(be)"),{description:e.options.description??n,fixedSize:e.size,littleEndian:r,maxSize:e.size}}function Ae(e){let r=be(e);return {description:r.description,encode(n){e.range&&Tr(e.name,e.range[0],e.range[1],n);let t=new ArrayBuffer(e.size);return e.set(new DataView(t),n,r.littleEndian),new Uint8Array(t)},fixedSize:r.fixedSize,maxSize:r.maxSize}}function ze(e){let r=be(e);return {decode(n,t=0){$(r.description,n,t),N(r.description,e.size,n,t);let o=new DataView(Sr(n,t,e.size));return [e.get(o,r.littleEndian),t+e.size]},description:r.description,fixedSize:r.fixedSize,maxSize:r.maxSize}}function Sr(e,r,n){let t=e.byteOffset+(r??0),o=n??e.byteLength;return e.buffer.slice(t,t+o)}var Ee=(e={})=>Ae({name:"u32",options:e,range:[0,+"0xffffffff"],set:(r,n,t)=>r.setUint32(0,n,t),size:4}),Ie=(e={})=>ze({get:(r,n)=>r.getUint32(0,n),name:"u32",options:e,size:4});var we=(e={})=>Ae({name:"u8",options:e,range:[0,+"0xff"],set:(r,n)=>r.setUint8(0,n),size:1}),Be=(e={})=>ze({get:r=>r.getUint8(0),name:"u8",options:e,size:1}),Ce=(e={})=>z(we(e),Be(e));function br(e,r,n=r){if(!r.match(new RegExp(`^[${e}]*$`)))throw new Error(`Expected a string of base ${e.length}, got [${n}].`)}var Ar=e=>{let r=e.length,n=BigInt(r);return {description:`base${r}`,encode(t){if(br(e,t),t==="")return new Uint8Array;let o=[...t],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),u=0n,d=1n;for(let f=c.length-1;f>=0;f-=1)u+=d*BigInt(e.indexOf(c[f])),d*=n;let l=[];for(;u>0n;)l.unshift(Number(u%256n)),u/=256n;return Uint8Array.from(s.concat(l))},fixedSize:null,maxSize:null}},zr=e=>{let r=e.length,n=BigInt(r);return {decode(t,o=0){let i=o===0?t:t.slice(o);if(i.length===0)return ["",0];let s=i.findIndex(l=>l!==0);s=s===-1?i.length:s;let c=e[0].repeat(s);if(s===i.length)return [c,t.length];let u=i.slice(s).reduce((l,f)=>l*256n+BigInt(f),0n),d=[];for(;u>0n;)d.unshift(e[Number(u%n)]),u/=n;return [c+d.join(""),t.length]},description:`base${r}`,fixedSize:null,maxSize:null}};var ve="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",De=()=>Ar(ve),Ne=()=>zr(ve);var Er=e=>e.replace(/\u0000/g,"");var Ir=globalThis.TextDecoder,wr=globalThis.TextEncoder,Br=()=>{let e;return {description:"utf8",encode:r=>new Uint8Array((e||(e=new wr)).encode(r)),fixedSize:null,maxSize:null}},Cr=()=>{let e;return {decode(r,n=0){let t=(e||(e=new Ir)).decode(r.slice(n));return [Er(t),r.length]},description:"utf8",fixedSize:null,maxSize:null}};var _e=(e={})=>{let r=e.size??Ee(),n=e.encoding??Br(),t=e.description??`string(${n.description}; ${Re(r)})`;return r==="variable"?{...n,description:t}:typeof r=="number"?te(n,r,t):{description:t,encode:o=>{let i=n.encode(o),s=r.encode(i.length);return K([s,i])},fixedSize:null,maxSize:null}},ke=(e={})=>{let r=e.size??Ie(),n=e.encoding??Cr(),t=e.description??`string(${n.description}; ${Re(r)})`;return r==="variable"?{...n,description:t}:typeof r=="number"?oe(n,r,t):{decode:(o,i=0)=>{$("string",o,i);let[s,c]=r.decode(o,i),u=Number(s);i=c;let d=o.slice(i,i+u);N("string",u,d);let[l,f]=n.decode(d);return i+=f,[l,i]},description:t,fixedSize:null,maxSize:null}};function Re(e){return typeof e=="object"?e.description:`${e}`}function Ue(){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 $e(){if(Ue(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.exportKey!="function")throw new Error("No key export implementation could be found")}async function Oe(){if(Ue(),typeof globalThis.crypto>"u"||typeof globalThis.crypto.subtle?.sign!="function")throw new Error("No signing implementation could be found")}var ie,se;function Le(){return ie||(ie=De()),ie}function vr(){return se||(se=Ne()),se}function Dr(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=Le().encode(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 base-58 encoded address`,{cause:r})}}function Nr(e){return Dr(e),e}function _r(e){return Se(_e({description:e?.description??"Base58EncodedAddress",encoding:Le(),size:32}),r=>Nr(r))}function Me(e){return ke({description:e?.description??"Base58EncodedAddress",encoding:vr(),size:32})}function Y(e){return z(_r(e),Me(e))}function O(){return new Intl.Collator("en",{caseFirst:"lower",ignorePunctuation:!1,localeMatcher:"best fit",numeric:!1,sensitivity:"variant",usage:"sort"}).compare}async function Pe(e){if(await $e(),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),[n]=Me().decode(new Uint8Array(r));return n}function Ve(e,r,n){e[r]=n(e[r]??{role:g.READONLY});}var m=Symbol("AddressMapTypeProperty");function Fe(e,r){let n={[e]:{[m]:0,role:g.WRITABLE_SIGNER}},t=new Set;for(let o of r){Ve(n,o.programAddress,s=>{if(t.add(o.programAddress),m in s){if(C(s.role))switch(s[m]){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[m]===2)return s}return {[m]:2,role:g.READONLY}});let i;if(o.accounts)for(let s of o.accounts)Ve(n,s.address,c=>{let{address:u,...d}=s;if(m in c)switch(c[m]){case 0:return c;case 1:{let l=re(c.role,d.role);if("lookupTableAddress"in d){if(c.lookupTableAddress!==d.lookupTableAddress&&(i||(i=O()))(d.lookupTableAddress,c.lookupTableAddress)<0)return {[m]:1,...d,role:l}}else if(B(d.role))return {[m]:2,role:l};return c.role!==l?{...c,role:l}:c}case 2:{let l=re(c.role,d.role);if(t.has(s.address)){if(C(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!==l?{...c,role:l}:c}else return "lookupTableAddress"in d&&!B(c.role)?{...d,[m]:1,role:l}:c.role!==l?{...c,role:l}:c}}return "lookupTableAddress"in d?{...d,[m]:1}:{...d,[m]:2}});}return n}function We(e){let r;return Object.entries(e).sort(([t,o],[i,s])=>{if(o[m]!==s[m]){if(o[m]===0)return -1;if(s[m]===0)return 1;if(o[m]===2)return -1;if(s[m]===2)return 1}let c=B(o.role);if(c!==B(s.role))return c?-1:1;let u=C(o.role);return u!==C(s.role)?u?-1:1:(r||(r=O()),o[m]===1&&s[m]===1&&o.lookupTableAddress!==s.lookupTableAddress?r(o.lookupTableAddress,s.lookupTableAddress):r(t,i))}).map(([t,o])=>({address:t,...o}))}function He(e){var n;let r={};for(let t of e){if(!("lookupTableAddress"in t))continue;let o=r[n=t.lookupTableAddress]||(r[n]={readableIndices:[],writableIndices:[]});t.role===g.WRITABLE?o.writableIndices.push(t.addressIndex):o.readableIndices.push(t.addressIndex);}return Object.keys(r).sort(O()).map(t=>({lookupTableAddress:t,...r[t]}))}function je(e){let r=0,n=0,t=0;for(let o of e){if("lookupTableAddress"in o)break;let i=C(o.role);B(o.role)?(t++,i||n++):i||r++;}return {numReadonlyNonSignerAccounts:r,numReadonlySignerAccounts:n,numSignerAccounts:t}}function kr(e){let r={};for(let[n,t]of e.entries())r[t.address]=n;return r}function Ke(e,r){let n=kr(r);return e.map(({accounts:t,data:o,programAddress:i})=>({programAddressIndex:n[i],...t?{accountIndices:t.map(({address:s})=>n[s])}:null,...o?{data:o}:null}))}function Ye(e){return "nonce"in e?e.nonce:e.blockhash}function Ge(e){let r=e.findIndex(t=>"lookupTableAddress"in t);return (r===-1?e:e.slice(0,r)).map(({address:t})=>t)}function G(e){let r=Fe(e.feePayer,e.instructions),n=We(r);return {...e.version!=="legacy"?{addressTableLookups:He(n)}:null,header:je(n),instructions:Ke(e.instructions,n),lifetimeToken:Ye(e.lifetimeConstraint),staticAccounts:Ge(n),version:e.version}}function qe(e){let r=G(e),n;if("signatures"in e){n=[];for(let t=0;t<r.header.numSignerAccounts;t++)n[t]=e.signatures[r.staticAccounts[t]]??new Uint8Array(Array(64).fill(0));}else n=Array(r.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));return {compiledMessage:r,signatures:n}}function Rr(e){let r=Y();return {description:e?.description??r.description,deserialize:r.decode,fixedSize:r.fixedSize,maxSize:r.maxSize,serialize:r.encode}}function Xe(){return T([["lookupTableAddress",Rr(void 0)],["writableIndices",h(w(),{size:p()})],["readableIndices",h(w(),{size:p()})]],void 0)}function Ze(e){return e.reduce((r,n)=>r===null||n===null?null:r+n,0)}function Je(e,r){let n=e.map(([t,o])=>`${String(t)}: ${o.description}`).join(", ");return {description:r??`struct(${n})`,fixedSize:Ze(e.map(([,t])=>t.fixedSize)),maxSize:Ze(e.map(([,t])=>t.maxSize))}}function Qe(e,r={}){return {...Je(e,r.description),encode:n=>{let t=e.map(([o,i])=>i.encode(n[o]));return K(t)}}}function er(e,r={}){return {...Je(e,r.description),decode:(n,t=0)=>{let o={};return e.forEach(([i,s])=>{let[c,u]=s.decode(n,t);t=u,o[i]=c;}),[o,t]}}}function rr(e,r={}){return z(Qe(e,r),er(e,r))}var ae;function Ur(){return ae||(ae=Ce()),ae}function ce(e){let r=Ur();return {...r,description:e??r.description}}var $r=void 0,Or=void 0,Lr=void 0,Mr=void 0;function nr(){return rr([["numSignerAccounts",ce($r)],["numReadonlySignerAccounts",ce(Or)],["numReadonlyNonSignerAccounts",ce(Lr)]],{description:Mr})}function tr(){return k(T([["programAddressIndex",w(void 0)],["accountIndices",h(w({description:""}),{description:"",size:p()})],["data",U({description:"",size:p()})]]),e=>e.accountIndices!==void 0&&e.data!==void 0?e:{...e,accountIndices:e.accountIndices??[],data:e.data??new Uint8Array(0)},e=>{if(e.accountIndices.length&&e.data.byteLength)return e;let{accountIndices:r,data:n,...t}=e;return {...t,...r.length?{accountIndices:r}:null,...n.byteLength?{data:n}:null}})}var de=128,or={description:"",fixedSize:null,maxSize:1};function Pr(e,r=0){let n=e[r];return n&de?[n^de,r+1]:["legacy",r]}function Vr(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|de])}function Fr(){return {...or,decode:Pr}}function Wr(){return {...or,encode:Vr}}function ir(){return z(Wr(),Fr())}function Hr(e,r){let n=r+e[0].toUpperCase()+e.slice(1);return new Error(`No ${e} exists for ${r}. Use \`get${n}()\` if you need a ${e}, and \`get${r}Codec()\` if you need to both encode and decode ${r}`)}function q(e){return ()=>{throw Hr("decoder",e)}}var jr={description:"",fixedSize:null,maxSize:null};function Kr(e){return e.version==="legacy"?T(sr()).serialize(e):k(T([...sr(),["addressTableLookups",Yr()]]),r=>r.version==="legacy"?r:{...r,addressTableLookups:r.addressTableLookups??[]}).serialize(e)}function ue(e){return {description:e.description,deserialize:e.decode,fixedSize:e.fixedSize,maxSize:e.maxSize,serialize:e.encode}}function sr(){return [["version",ue(ir())],["header",ue(nr())],["staticAccounts",h(ue(Y()),{description:"",size:p()})],["lifetimeToken",ee({description:"",encoding:E,size:32})],["instructions",h(tr(),{description:"",size:p()})]]}function Yr(){return h(Xe(),{size:p()})}function X(){return {...jr,deserialize:q("CompiledMessage"),serialize:Kr}}var Gr={description:"",fixedSize:null,maxSize:null};function qr(e){let r=qe(e);return T([["signatures",h(U({size:64}),{size:p()})],["compiledMessage",X()]]).serialize(r)}function ar(){return {...Gr,deserialize:q("CompiledMessage"),serialize:qr}}async function cr(e,r){await Oe();let n=await crypto.subtle.sign("Ed25519",e,r);return new Uint8Array(n)}function Xr(e){try{if(e.length<64||e.length>88)throw new Error("Expected input string to decode to a byte array of length 64.");let n=E.serialize(e).byteLength;if(n!==64)throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${n}`)}catch(r){throw new Error(`\`${e}\` is not a transaction signature`,{cause:r})}}function Ns(e){return !(e.length<64||e.length>88||E.serialize(e).byteLength!==64)}async function Zr(e,r){let n=X().serialize(e);return await cr(r,n)}function _s(e){let r=e.signatures[e.feePayer];if(!r)throw new Error("Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer.");return r}async function ks(e,r){let n=G(r),t="signatures"in r?{...r.signatures}:{},o=await Promise.all(e.map(s=>Promise.all([Pe(s.publicKey),Zr(n,s.privateKey)])));for(let[s,c]of o)t[s]=c;let i={...r,signatures:t};return Object.freeze(i),i}function Rs(e){return Xr(e),e}function Ls(e){let r=ar().serialize(e);return btoa(String.fromCharCode(...r))}
6
6
 
7
- exports.appendTransactionInstruction = m;
8
- exports.createTransaction = T;
9
- exports.prependTransactionInstruction = x;
10
- exports.setTransactionFeePayer = d;
7
+ exports.appendTransactionInstruction = To;
8
+ exports.assertIsBlockhash = qt;
9
+ exports.assertIsDurableNonceTransaction = uo;
10
+ exports.assertIsTransactionSignature = Xr;
11
+ exports.createTransaction = Qt;
12
+ exports.getBase64EncodedWireTransaction = Ls;
13
+ exports.getSignatureFromTransaction = _s;
14
+ exports.getTransactionEncoder = ar;
15
+ exports.isTransactionSignature = Ns;
16
+ exports.prependTransactionInstruction = So;
17
+ exports.setTransactionFeePayer = po;
18
+ exports.setTransactionLifetimeUsingBlockhash = Xt;
19
+ exports.setTransactionLifetimeUsingDurableNonce = lo;
20
+ exports.signTransaction = ks;
21
+ exports.transactionSignature = Rs;
11
22
 
12
23
  return exports;
13
24
 
package/dist/types/accounts.d.ts ADDED
@@ -0,0 +1,28 @@
1
+ import { Base58EncodedAddress } from '@solana/addresses';
2
+ import { IAccountLookupMeta, IAccountMeta, IInstruction, ReadonlyAccount, ReadonlyAccountLookup, ReadonlySignerAccount, WritableAccount, WritableAccountLookup, WritableSignerAccount } from '@solana/instructions';
3
+ export declare const enum AddressMapEntryType {
4
+ FEE_PAYER = 0,
5
+ LOOKUP_TABLE = 1,
6
+ STATIC = 2
7
+ }
8
+ type AddressMap = {
9
+ [address: string]: FeePayerAccountEntry | LookupTableAccountEntry | StaticAccountEntry;
10
+ };
11
+ type FeePayerAccountEntry = Omit<WritableSignerAccount, 'address'> & {
12
+ [TYPE]: AddressMapEntryType.FEE_PAYER;
13
+ };
14
+ type LookupTableAccountEntry = Omit<ReadonlyAccountLookup | WritableAccountLookup, 'address'> & {
15
+ [TYPE]: AddressMapEntryType.LOOKUP_TABLE;
16
+ };
17
+ export type OrderedAccounts = (IAccountMeta | IAccountLookupMeta)[] & {
18
+ readonly __brand: unique symbol;
19
+ };
20
+ type StaticAccountEntry = Omit<ReadonlyAccount | ReadonlySignerAccount | WritableAccount | WritableSignerAccount, 'address'> & {
21
+ [TYPE]: AddressMapEntryType.STATIC;
22
+ };
23
+ declare const TYPE: unique symbol;
24
+ export declare const ADDRESS_MAP_TYPE_PROPERTY: typeof TYPE;
25
+ export declare function getAddressMapFromInstructions(feePayer: Base58EncodedAddress, instructions: readonly IInstruction[]): AddressMap;
26
+ export declare function getOrderedAccountsFromAddressMap(addressMap: AddressMap): OrderedAccounts;
27
+ export {};
28
+ //# sourceMappingURL=accounts.d.ts.map
package/dist/types/blockhash.d.ts CHANGED
@@ -1,4 +1,9 @@
1
- import { Blockhash } from '@solana/rpc-core';
1
+ import { IDurableNonceTransaction } from './durable-nonce';
2
+ import { ITransactionWithSignatures } from './signatures';
3
+ import { BaseTransaction } from './types';
4
+ export type Blockhash = string & {
5
+ readonly __brand: unique symbol;
6
+ };
2
7
  type BlockhashLifetimeConstraint = Readonly<{
3
8
  blockhash: Blockhash;
4
9
  lastValidBlockHeight: bigint;
@@ -6,5 +11,8 @@ type BlockhashLifetimeConstraint = Readonly<{
6
11
  export interface ITransactionWithBlockhashLifetime {
7
12
  readonly lifetimeConstraint: BlockhashLifetimeConstraint;
8
13
  }
14
+ export declare function assertIsBlockhash(putativeBlockhash: string): asserts putativeBlockhash is Blockhash;
15
+ export declare function setTransactionLifetimeUsingBlockhash<TTransaction extends BaseTransaction & IDurableNonceTransaction>(blockhashLifetimeConstraint: BlockhashLifetimeConstraint, transaction: TTransaction | (TTransaction & ITransactionWithSignatures)): Omit<TTransaction, keyof ITransactionWithSignatures | 'lifetimeConstraint'> & ITransactionWithBlockhashLifetime;
16
+ export declare function setTransactionLifetimeUsingBlockhash<TTransaction extends BaseTransaction | (BaseTransaction & ITransactionWithBlockhashLifetime)>(blockhashLifetimeConstraint: BlockhashLifetimeConstraint, transaction: TTransaction | (TTransaction & ITransactionWithSignatures)): Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithBlockhashLifetime;
9
17
  export {};
10
18
  //# sourceMappingURL=blockhash.d.ts.map
package/dist/types/compile-address-table-lookups.d.ts ADDED
@@ -0,0 +1,10 @@
1
+ import { Base58EncodedAddress } from '@solana/addresses';
2
+ import { OrderedAccounts } from './accounts';
3
+ type AddressTableLookup = Readonly<{
4
+ lookupTableAddress: Base58EncodedAddress;
5
+ readableIndices: readonly number[];
6
+ writableIndices: readonly number[];
7
+ }>;
8
+ export declare function getCompiledAddressTableLookups(orderedAccounts: OrderedAccounts): AddressTableLookup[];
9
+ export {};
10
+ //# sourceMappingURL=compile-address-table-lookups.d.ts.map
package/dist/types/compile-header.d.ts ADDED
@@ -0,0 +1,9 @@
1
+ import { OrderedAccounts } from './accounts';
2
+ type MessageHeader = Readonly<{
3
+ numReadonlyNonSignerAccounts: number;
4
+ numReadonlySignerAccounts: number;
5
+ numSignerAccounts: number;
6
+ }>;
7
+ export declare function getCompiledMessageHeader(orderedAccounts: OrderedAccounts): MessageHeader;
8
+ export {};
9
+ //# sourceMappingURL=compile-header.d.ts.map
package/dist/types/compile-instructions.d.ts ADDED
@@ -0,0 +1,10 @@
1
+ import { IInstruction } from '@solana/instructions';
2
+ import { OrderedAccounts } from './accounts';
3
+ type CompiledInstruction = Readonly<{
4
+ accountIndices?: number[];
5
+ data?: Uint8Array;
6
+ programAddressIndex: number;
7
+ }>;
8
+ export declare function getCompiledInstructions(instructions: readonly IInstruction[], orderedAccounts: OrderedAccounts): CompiledInstruction[];
9
+ export {};
10
+ //# sourceMappingURL=compile-instructions.d.ts.map
package/dist/types/compile-lifetime-token.d.ts ADDED
@@ -0,0 +1,3 @@
1
+ import { IDurableNonceTransaction, ITransactionWithBlockhashLifetime } from './index';
2
+ export declare function getCompiledLifetimeToken(lifetimeConstraint: (ITransactionWithBlockhashLifetime | IDurableNonceTransaction)['lifetimeConstraint']): string;
3
+ //# sourceMappingURL=compile-lifetime-token.d.ts.map
package/dist/types/compile-static-accounts.d.ts ADDED
@@ -0,0 +1,4 @@
1
+ import { Base58EncodedAddress } from '@solana/addresses';
2
+ import { OrderedAccounts } from './accounts';
3
+ export declare function getCompiledStaticAccounts(orderedAccounts: OrderedAccounts): Base58EncodedAddress[];
4
+ //# sourceMappingURL=compile-static-accounts.d.ts.map
package/dist/types/compile-transaction.d.ts ADDED
@@ -0,0 +1,11 @@
1
+ import { Ed25519Signature } from '@solana/keys';
2
+ import { CompiledMessage, compileMessage } from './message';
3
+ import { ITransactionWithSignatures } from './signatures';
4
+ type CompiledTransaction = Readonly<{
5
+ compiledMessage: CompiledMessage;
6
+ signatures: Ed25519Signature[];
7
+ }>;
8
+ type CompilableTransaction = Parameters<typeof compileMessage>[0];
9
+ export declare function getCompiledTransaction(transaction: CompilableTransaction | (CompilableTransaction & ITransactionWithSignatures)): CompiledTransaction;
10
+ export {};
11
+ //# sourceMappingURL=compile-transaction.d.ts.map
package/dist/types/durable-nonce.d.ts CHANGED
@@ -1,22 +1,35 @@
1
+ import { Base58EncodedAddress } from '@solana/addresses';
1
2
  import { IInstruction, IInstructionWithAccounts, IInstructionWithData } from '@solana/instructions';
2
3
  import { ReadonlyAccount, ReadonlySignerAccount, WritableAccount } from '@solana/instructions/dist/types/accounts';
3
- type AdvanceNonceAccountInstruction<TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string> = IInstruction<'11111111111111111111111111111111'> & IInstructionWithAccounts<[
4
+ import { ITransactionWithSignatures } from './signatures';
5
+ import { BaseTransaction } from './types';
6
+ type AdvanceNonceAccountInstruction<TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string> = IInstruction<'11111111111111111111111111111111'> & IInstructionWithAccounts<readonly [
4
7
  WritableAccount<TNonceAccountAddress>,
5
8
  ReadonlyAccount<'SysvarRecentB1ockHashes11111111111111111111'>,
6
9
  ReadonlySignerAccount<TNonceAuthorityAddress>
7
10
  ]> & IInstructionWithData<AdvanceNonceAccountInstructionData>;
8
11
  type AdvanceNonceAccountInstructionData = Uint8Array & {
9
- readonly __advanceNonceAccountInstructionData: unique symbol;
12
+ readonly __brand: unique symbol;
10
13
  };
11
- type NonceLifetimeConstraint = Readonly<{
12
- nonce: string;
14
+ type DurableNonceConfig<TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string, TNonceValue extends string = string> = Readonly<{
15
+ readonly nonce: Nonce<TNonceValue>;
16
+ readonly nonceAccountAddress: Base58EncodedAddress<TNonceAccountAddress>;
17
+ readonly nonceAuthorityAddress: Base58EncodedAddress<TNonceAuthorityAddress>;
13
18
  }>;
14
- export interface IDurableNonceTransaction<TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string> {
15
- readonly instructions: [
19
+ export type Nonce<TNonceValue extends string = string> = TNonceValue & {
20
+ readonly __brand: unique symbol;
21
+ };
22
+ type NonceLifetimeConstraint<TNonceValue extends string = string> = Readonly<{
23
+ nonce: Nonce<TNonceValue>;
24
+ }>;
25
+ export interface IDurableNonceTransaction<TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string, TNonceValue extends string = string> {
26
+ readonly instructions: readonly [
16
27
  AdvanceNonceAccountInstruction<TNonceAccountAddress, TNonceAuthorityAddress>,
17
28
  ...IInstruction[]
18
29
  ];
19
- readonly lifetimeConstraint: NonceLifetimeConstraint;
30
+ readonly lifetimeConstraint: NonceLifetimeConstraint<TNonceValue>;
20
31
  }
32
+ export declare function assertIsDurableNonceTransaction(transaction: BaseTransaction | (BaseTransaction & IDurableNonceTransaction)): asserts transaction is BaseTransaction & IDurableNonceTransaction;
33
+ export declare function setTransactionLifetimeUsingDurableNonce<TTransaction extends BaseTransaction, TNonceAccountAddress extends string = string, TNonceAuthorityAddress extends string = string, TNonceValue extends string = string>({ nonce, nonceAccountAddress, nonceAuthorityAddress, }: DurableNonceConfig<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>, transaction: TTransaction | (TTransaction & IDurableNonceTransaction)): Omit<TTransaction, keyof ITransactionWithSignatures> & IDurableNonceTransaction<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>;
21
34
  export {};
22
35
  //# sourceMappingURL=durable-nonce.d.ts.map
package/dist/types/fee-payer.d.ts CHANGED
@@ -1,8 +1,9 @@
1
- import { Base58EncodedAddress } from '@solana/keys';
1
+ import { Base58EncodedAddress } from '@solana/addresses';
2
2
  import { ITransactionWithSignatures } from './signatures';
3
3
  import { BaseTransaction } from './types';
4
4
  export interface ITransactionWithFeePayer<TAddress extends string = string> {
5
5
  readonly feePayer: Base58EncodedAddress<TAddress>;
6
6
  }
7
- export declare function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(feePayer: Base58EncodedAddress<TFeePayerAddress>, transaction: TTransaction | (TTransaction & ITransactionWithFeePayer<TFeePayerAddress>) | (TTransaction & ITransactionWithSignatures) | (TTransaction & ITransactionWithFeePayer<TFeePayerAddress> & ITransactionWithSignatures)): (TTransaction & ITransactionWithFeePayer<TFeePayerAddress>) | (Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithFeePayer<TFeePayerAddress>);
7
+ export declare function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(feePayer: Base58EncodedAddress<TFeePayerAddress>, transaction: (TTransaction & ITransactionWithSignatures) | (TTransaction & ITransactionWithFeePayer<string> & ITransactionWithSignatures)): Omit<TTransaction, keyof ITransactionWithSignatures> & ITransactionWithFeePayer<TFeePayerAddress>;
8
+ export declare function setTransactionFeePayer<TFeePayerAddress extends string, TTransaction extends BaseTransaction>(feePayer: Base58EncodedAddress<TFeePayerAddress>, transaction: TTransaction | (TTransaction & ITransactionWithFeePayer<string>)): TTransaction & ITransactionWithFeePayer<TFeePayerAddress>;
8
9
  //# sourceMappingURL=fee-payer.d.ts.map
package/dist/types/index.d.ts CHANGED
@@ -3,6 +3,8 @@ export * from './create-transaction';
3
3
  export * from './durable-nonce';
4
4
  export * from './fee-payer';
5
5
  export * from './instructions';
6
+ export * from './serializers';
6
7
  export * from './signatures';
7
8
  export * from './types';
9
+ export * from './wire-transaction';
8
10
  //# sourceMappingURL=index.d.ts.map
package/dist/types/message.d.ts ADDED
@@ -0,0 +1,30 @@
1
+ import { ITransactionWithBlockhashLifetime } from './blockhash';
2
+ import { getCompiledAddressTableLookups } from './compile-address-table-lookups';
3
+ import { getCompiledMessageHeader } from './compile-header';
4
+ import { getCompiledInstructions } from './compile-instructions';
5
+ import { getCompiledLifetimeToken } from './compile-lifetime-token';
6
+ import { getCompiledStaticAccounts } from './compile-static-accounts';
7
+ import { IDurableNonceTransaction } from './durable-nonce';
8
+ import { ITransactionWithFeePayer } from './fee-payer';
9
+ import { BaseTransaction } from './types';
10
+ type BaseCompiledMessage = Readonly<{
11
+ header: ReturnType<typeof getCompiledMessageHeader>;
12
+ instructions: ReturnType<typeof getCompiledInstructions>;
13
+ lifetimeToken: ReturnType<typeof getCompiledLifetimeToken>;
14
+ staticAccounts: ReturnType<typeof getCompiledStaticAccounts>;
15
+ }>;
16
+ type CompilableTransaction = BaseTransaction & ITransactionWithFeePayer & (ITransactionWithBlockhashLifetime | IDurableNonceTransaction);
17
+ export type CompiledMessage = LegacyCompiledMessage | VersionedCompiledMessage;
18
+ type LegacyCompiledMessage = BaseCompiledMessage & Readonly<{
19
+ version: 'legacy';
20
+ }>;
21
+ type VersionedCompiledMessage = BaseCompiledMessage & Readonly<{
22
+ addressTableLookups?: ReturnType<typeof getCompiledAddressTableLookups>;
23
+ version: number;
24
+ }>;
25
+ export declare function compileMessage(transaction: CompilableTransaction & Readonly<{
26
+ version: 'legacy';
27
+ }>): LegacyCompiledMessage;
28
+ export declare function compileMessage(transaction: CompilableTransaction): VersionedCompiledMessage;
29
+ export {};
30
+ //# sourceMappingURL=message.d.ts.map
package/dist/types/serializers/address-table-lookup.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { Serializer } from '@metaplex-foundation/umi-serializers';
2
+ import { getCompiledAddressTableLookups } from '../compile-address-table-lookups';
3
+ type AddressTableLookup = ReturnType<typeof getCompiledAddressTableLookups>[number];
4
+ export declare function getAddressTableLookupCodec(): Serializer<AddressTableLookup>;
5
+ export {};
6
+ //# sourceMappingURL=address-table-lookup.d.ts.map
package/dist/types/serializers/header.d.ts ADDED
@@ -0,0 +1,8 @@
1
+ import { Codec, Decoder, Encoder } from '@solana/codecs-core';
2
+ import { getCompiledMessageHeader } from '../compile-header';
3
+ type MessageHeader = ReturnType<typeof getCompiledMessageHeader>;
4
+ export declare function getMessageHeaderEncoder(): Encoder<MessageHeader>;
5
+ export declare function getMessageHeaderDecoder(): Decoder<MessageHeader>;
6
+ export declare function getMessageHeaderCodec(): Codec<MessageHeader>;
7
+ export {};
8
+ //# sourceMappingURL=header.d.ts.map
package/dist/types/serializers/index.d.ts ADDED
@@ -0,0 +1,2 @@
1
+ export * from './transaction';
2
+ //# sourceMappingURL=index.d.ts.map
package/dist/types/serializers/instruction.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { Serializer } from '@metaplex-foundation/umi-serializers';
2
+ import { getCompiledInstructions } from '../compile-instructions';
3
+ type Instruction = ReturnType<typeof getCompiledInstructions>[number];
4
+ export declare function getInstructionCodec(): Serializer<Instruction>;
5
+ export {};
6
+ //# sourceMappingURL=instruction.d.ts.map
package/dist/types/serializers/message.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { Serializer } from '@metaplex-foundation/umi-serializers';
2
+ import { CompiledMessage } from '../message';
3
+ export declare function getCompiledMessageEncoder(): Serializer<CompiledMessage>;
4
+ export declare function getCompiledMessageDecoder(): Serializer<CompiledMessage>;
5
+ export declare function getCompiledMessageCodec(): Serializer<CompiledMessage>;
6
+ //# sourceMappingURL=message.d.ts.map
package/dist/types/serializers/transaction-version.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { Codec, Decoder, Encoder } from '@solana/codecs-core';
2
+ import { TransactionVersion } from '../types';
3
+ export declare function getTransactionVersionDecoder(): Decoder<TransactionVersion>;
4
+ export declare function getTransactionVersionEncoder(): Encoder<TransactionVersion>;
5
+ export declare function getTransactionVersionCodec(): Codec<TransactionVersion>;
6
+ //# sourceMappingURL=transaction-version.d.ts.map
package/dist/types/serializers/transaction.d.ts ADDED
@@ -0,0 +1,6 @@
1
+ import { Serializer } from '@metaplex-foundation/umi-serializers';
2
+ import { getCompiledTransaction } from '../compile-transaction';
3
+ type SerializableTransaction = Parameters<typeof getCompiledTransaction>[0];
4
+ export declare function getTransactionEncoder(): Serializer<SerializableTransaction>;
5
+ export {};
6
+ //# sourceMappingURL=transaction.d.ts.map
package/dist/types/serializers/unimplemented.d.ts ADDED
@@ -0,0 +1,3 @@
1
+ export declare function getUnimplementedDecoder(name: string): () => never;
2
+ export declare function getUnimplementedEncoder(name: string): () => never;
3
+ //# sourceMappingURL=unimplemented.d.ts.map
package/dist/types/signatures.d.ts CHANGED
@@ -1,12 +1,19 @@
1
- import { Base58EncodedAddress } from '@solana/keys';
2
- type Base64EncodedSignature = string & {
3
- readonly __base64EncodedSignature: unique symbol;
4
- };
1
+ import { Base58EncodedAddress } from '@solana/addresses';
2
+ import { Ed25519Signature } from '@solana/keys';
3
+ import { ITransactionWithFeePayer } from './fee-payer';
4
+ import { compileMessage } from './message';
5
5
  export interface IFullySignedTransaction extends ITransactionWithSignatures {
6
- readonly __fullySignedTransaction: unique symbol;
6
+ readonly __brand: unique symbol;
7
7
  }
8
8
  export interface ITransactionWithSignatures {
9
- readonly signatures: Readonly<Record<Base58EncodedAddress, Base64EncodedSignature>>;
9
+ readonly signatures: Readonly<Record<Base58EncodedAddress, Ed25519Signature>>;
10
10
  }
11
- export {};
11
+ export type TransactionSignature = string & {
12
+ readonly __brand: unique symbol;
13
+ };
14
+ export declare function assertIsTransactionSignature(putativeTransactionSignature: string): asserts putativeTransactionSignature is TransactionSignature;
15
+ export declare function isTransactionSignature(putativeTransactionSignature: string): putativeTransactionSignature is TransactionSignature;
16
+ export declare function getSignatureFromTransaction(transaction: ITransactionWithFeePayer & ITransactionWithSignatures): TransactionSignature;
17
+ export declare function signTransaction<TTransaction extends Parameters<typeof compileMessage>[0]>(keyPairs: CryptoKeyPair[], transaction: TTransaction | (TTransaction & ITransactionWithSignatures)): Promise<TTransaction & ITransactionWithSignatures>;
18
+ export declare function transactionSignature(putativeTransactionSignature: string): TransactionSignature;
12
19
  //# sourceMappingURL=signatures.d.ts.map