@algorandfoundation/algokit-utils 10.0.0-alpha.3 → 10.0.0-alpha.32

package/packages/transact/src/logicsig.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"logicsig.mjs","names":["args: Uint8Array[]","signedTxns: Uint8Array[]","stxn: SignedTransaction"],"sources":["../../../../packages/transact/src/logicsig.ts"],"sourcesContent":["import { Address, concatArrays, decodeMsgpack, hash, isValidAddress } from '@algorandfoundation/algokit-common'\nimport { MultisigAccount } from './multisig'\nimport { TransactionSigner } from './signer'\nimport { LogicSignature, MultisigSignature, SignedTransaction, encodeSignedTransaction } from './transactions/signed-transaction'\nimport { logicSignatureCodec } from './transactions/signed-transaction-meta'\nimport { Transaction } from './transactions/transaction'\n\n// base64regex is the regex to test for base64 strings\nconst base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/\n\n/** sanityCheckProgram performs heuristic program validation:\n * check if passed in bytes are Algorand address or is B64 encoded, rather than Teal bytes\n *\n * @param program - Program bytes to check\n */\nexport function sanityCheckProgram(program: Uint8Array) {\n  if (!program || program.length === 0) throw new Error('empty program')\n\n  const lineBreakOrd = '\\n'.charCodeAt(0)\n  const blankSpaceOrd = ' '.charCodeAt(0)\n  const tildeOrd = '~'.charCodeAt(0)\n\n  const isPrintable = (x: number) => blankSpaceOrd <= x && x <= tildeOrd\n  const isAsciiPrintable = program.every((x: number) => x === lineBreakOrd || isPrintable(x))\n\n  if (isAsciiPrintable) {\n    const programStr = new TextDecoder().decode(program)\n\n    if (isValidAddress(programStr)) throw new Error('requesting program bytes, get Algorand address')\n\n    if (base64regex.test(programStr)) throw new Error('program should not be b64 encoded')\n\n    throw new Error('program bytes are all ASCII printable characters, not looking like Teal byte code')\n  }\n}\n\nconst PROGRAM_TAG = new TextEncoder().encode('Program')\nconst MSIG_PROGRAM_TAG = new TextEncoder().encode('MsigProgram')\nconst SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode('ProgData')\n\n/** Function for signing logic signatures for delegation */\nexport type DelegatedLsigSigner = (lsig: LogicSigAccount, msig?: MultisigAccount) => Promise<Uint8Array>\n\n/** Function for signing program data for a logic signature */\nexport type ProgramDataSigner = (data: Uint8Array, lsig: LogicSigAccount) => Promise<Uint8Array>\n\nexport class LogicSigAccount {\n  logic: Uint8Array\n  args: Uint8Array[]\n  sig?: Uint8Array\n  msig?: MultisigSignature\n  lmsig?: MultisigSignature\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null) {\n    if (programArgs && (!Array.isArray(programArgs) || !programArgs.every((arg) => arg.constructor === Uint8Array))) {\n      throw new TypeError('Invalid arguments')\n    }\n\n    let args: Uint8Array[] = []\n    if (programArgs != null) args = programArgs.map((arg) => new Uint8Array(arg))\n\n    sanityCheckProgram(program)\n\n    this.logic = program\n    this.args = args\n  }\n\n  get signer(): TransactionSigner {\n    return async (txns: Transaction[], indexes: number[]) => {\n      const signedTxns: Uint8Array[] = []\n      for (const index of indexes) {\n        const txn = txns[index]\n\n        const stxn: SignedTransaction = {\n          txn,\n          lsig: { logic: this.logic, args: this.args, msig: this.msig, lmsig: this.lmsig, sig: this.sig },\n        }\n\n        signedTxns.push(encodeSignedTransaction(stxn))\n      }\n\n      return signedTxns\n    }\n  }\n\n  get addr(): Address {\n    return this.address()\n  }\n\n  /**\n   * Compute hash of the logic sig program (that is the same as escrow account address) as string address\n   * @returns String representation of the address\n   */\n  address(): Address {\n    const toBeSigned = concatArrays(PROGRAM_TAG, this.logic)\n    const h = hash(toBeSigned)\n    return new Address(h)\n  }\n\n  async delegate(signer: DelegatedLsigSigner) {\n    this.sig = await signer(this)\n  }\n\n  async delegateMultisig(msig: MultisigAccount) {\n    if (this.lmsig == undefined) {\n      this.lmsig = {\n        subsignatures: [],\n        version: msig.params.version,\n        threshold: msig.params.threshold,\n      }\n    }\n    for (const addrWithSigner of msig.subSigners) {\n      const { lsigSigner, addr } = addrWithSigner\n      const signature = await lsigSigner(this, msig)\n\n      this.lmsig.subsignatures.push({ publicKey: addr.publicKey, signature })\n    }\n  }\n\n  bytesToSignForDelegation(msig?: MultisigAccount): Uint8Array {\n    if (msig) {\n      return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic)\n    } else {\n      return concatArrays(PROGRAM_TAG, this.logic)\n    }\n  }\n\n  signProgramData(data: Uint8Array, signer: ProgramDataSigner): Promise<Uint8Array> {\n    return signer(data, this)\n  }\n\n  programDataToSign(data: Uint8Array): Uint8Array {\n    return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data)\n  }\n}\n\n/**\n * Decodes MsgPack bytes into a logic signature.\n *\n * @param encodedLogicSignature - The MsgPack encoded logic signature\n * @returns The decoded LogicSignature or an error if decoding fails.\n */\nexport function decodeLogicSignature(encodedLogicSignature: Uint8Array): LogicSignature {\n  const decodedData = decodeMsgpack(encodedLogicSignature)\n  return logicSignatureCodec.decode(decodedData, 'msgpack')\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,cAAc;;;;;;AAOpB,SAAgB,mBAAmB,SAAqB;AACtD,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,OAAM,IAAI,MAAM,gBAAgB;CAEtE,MAAM,eAAe,KAAK,WAAW,EAAE;CACvC,MAAM,gBAAgB,IAAI,WAAW,EAAE;CACvC,MAAM,WAAW,IAAI,WAAW,EAAE;CAElC,MAAM,eAAe,MAAc,iBAAiB,KAAK,KAAK;AAG9D,KAFyB,QAAQ,OAAO,MAAc,MAAM,gBAAgB,YAAY,EAAE,CAAC,EAErE;EACpB,MAAM,aAAa,IAAI,aAAa,CAAC,OAAO,QAAQ;AAEpD,MAAI,eAAe,WAAW,CAAE,OAAM,IAAI,MAAM,iDAAiD;AAEjG,MAAI,YAAY,KAAK,WAAW,CAAE,OAAM,IAAI,MAAM,oCAAoC;AAEtF,QAAM,IAAI,MAAM,oFAAoF;;;AAIxG,MAAM,cAAc,IAAI,aAAa,CAAC,OAAO,UAAU;AACvD,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,cAAc;AAChE,MAAM,2BAA2B,IAAI,aAAa,CAAC,OAAO,WAAW;AAQrE,IAAa,kBAAb,MAA6B;CAC3B;CACA;CACA;CACA;CACA;CAEA,YAAY,SAAqB,aAAwC;AACvE,MAAI,gBAAgB,CAAC,MAAM,QAAQ,YAAY,IAAI,CAAC,YAAY,OAAO,QAAQ,IAAI,gBAAgB,WAAW,EAC5G,OAAM,IAAI,UAAU,oBAAoB;EAG1C,IAAIA,OAAqB,EAAE;AAC3B,MAAI,eAAe,KAAM,QAAO,YAAY,KAAK,QAAQ,IAAI,WAAW,IAAI,CAAC;AAE7E,qBAAmB,QAAQ;AAE3B,OAAK,QAAQ;AACb,OAAK,OAAO;;CAGd,IAAI,SAA4B;AAC9B,SAAO,OAAO,MAAqB,YAAsB;GACvD,MAAMC,aAA2B,EAAE;AACnC,QAAK,MAAM,SAAS,SAAS;IAG3B,MAAMC,OAA0B;KAC9B,KAHU,KAAK;KAIf,MAAM;MAAE,OAAO,KAAK;MAAO,MAAM,KAAK;MAAM,MAAM,KAAK;MAAM,OAAO,KAAK;MAAO,KAAK,KAAK;MAAK;KAChG;AAED,eAAW,KAAK,wBAAwB,KAAK,CAAC;;AAGhD,UAAO;;;CAIX,IAAI,OAAgB;AAClB,SAAO,KAAK,SAAS;;;;;;CAOvB,UAAmB;AAGjB,SAAO,IAAI,QADD,KADS,aAAa,aAAa,KAAK,MAAM,CAC9B,CACL;;CAGvB,MAAM,SAAS,QAA6B;AAC1C,OAAK,MAAM,MAAM,OAAO,KAAK;;CAG/B,MAAM,iBAAiB,MAAuB;AAC5C,MAAI,KAAK,SAAS,OAChB,MAAK,QAAQ;GACX,eAAe,EAAE;GACjB,SAAS,KAAK,OAAO;GACrB,WAAW,KAAK,OAAO;GACxB;AAEH,OAAK,MAAM,kBAAkB,KAAK,YAAY;GAC5C,MAAM,EAAE,YAAY,SAAS;GAC7B,MAAM,YAAY,MAAM,WAAW,MAAM,KAAK;AAE9C,QAAK,MAAM,cAAc,KAAK;IAAE,WAAW,KAAK;IAAW;IAAW,CAAC;;;CAI3E,yBAAyB,MAAoC;AAC3D,MAAI,KACF,QAAO,aAAa,kBAAkB,KAAK,KAAK,WAAW,KAAK,MAAM;MAEtE,QAAO,aAAa,aAAa,KAAK,MAAM;;CAIhD,gBAAgB,MAAkB,QAAgD;AAChF,SAAO,OAAO,MAAM,KAAK;;CAG3B,kBAAkB,MAA8B;AAC9C,SAAO,aAAa,0BAA0B,KAAK,SAAS,CAAC,WAAW,KAAK;;;;;;;;;AAUjF,SAAgB,qBAAqB,uBAAmD;CACtF,MAAM,cAAc,cAAc,sBAAsB;AACxD,QAAO,oBAAoB,OAAO,aAAa,UAAU"}
+{"version":3,"file":"logicsig.mjs","names":["signedTxns: Uint8Array[]","stxn: SignedTransaction"],"sources":["../../../../packages/transact/src/logicsig.ts"],"sourcesContent":["import { Address, Addressable, concatArrays, decodeMsgpack, hash } from '@algorandfoundation/algokit-common'\nimport { MultisigAccount } from './multisig'\nimport { AddressWithDelegatedLsigSigner, TransactionSigner } from './signer'\nimport {\n  LogicSigSignature,\n  MultisigSignature,\n  SignedTransaction,\n  encodeSignedTransaction,\n  validateSignedTransaction,\n} from './transactions/signed-transaction'\nimport { logicSigSignatureCodec } from './transactions/signed-transaction-meta'\nimport { Transaction } from './transactions/transaction'\n\nconst PROGRAM_TAG = new TextEncoder().encode('Program')\nconst MSIG_PROGRAM_TAG = new TextEncoder().encode('MsigProgram')\nconst SIGN_PROGRAM_DATA_PREFIX = new TextEncoder().encode('ProgData')\n\n/** Function for signing logic signatures for delegation\n *  @param lsig - The logic signature that is being signed for delegation\n *  @param msig - Optional multisig account that should be set when a public key is signing as a subsigner of a multisig\n *  @returns The address of the delegator\n * */\nexport type DelegatedLsigSigner = (\n  lsig: LogicSigAccount,\n  msig?: MultisigAccount,\n) => Promise<{ addr: Address } & ({ sig?: Uint8Array } | { lmsig?: MultisigSignature })>\n\n/** Function for signing program data for a logic signature */\nexport type ProgramDataSigner = (data: Uint8Array, lsig: LogicSig) => Promise<Uint8Array>\n\nexport class LogicSig implements Addressable {\n  logic: Uint8Array\n  args: Uint8Array[]\n  protected _addr: Address\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array>) {\n    this.logic = program\n    this.args = programArgs ?? []\n    const toBeSigned = concatArrays(PROGRAM_TAG, this.logic)\n    const h = hash(toBeSigned)\n    this._addr = new Address(h)\n  }\n\n  static fromSignature(signature: LogicSigSignature): LogicSig {\n    return new LogicSig(signature.logic, signature.args || [])\n  }\n\n  static fromBytes(encodedLsig: Uint8Array): LogicSig {\n    const decoded = decodeMsgpack(encodedLsig)\n    const lsigSignature = logicSigSignatureCodec.decode(decoded, 'msgpack')\n    return LogicSig.fromSignature(lsigSignature)\n  }\n\n  address(): Address {\n    return this._addr\n  }\n\n  get addr(): Address {\n    return this._addr\n  }\n\n  bytesToSignForDelegation(msig?: MultisigAccount): Uint8Array {\n    if (msig) {\n      return concatArrays(MSIG_PROGRAM_TAG, msig.addr.publicKey, this.logic)\n    } else {\n      return concatArrays(PROGRAM_TAG, this.logic)\n    }\n  }\n\n  signProgramData(data: Uint8Array, signer: ProgramDataSigner): Promise<Uint8Array> {\n    return signer(data, this)\n  }\n\n  programDataToSign(data: Uint8Array): Uint8Array {\n    return concatArrays(SIGN_PROGRAM_DATA_PREFIX, this.address().publicKey, data)\n  }\n\n  account(): LogicSigAccount {\n    return new LogicSigAccount(this.logic, this.args)\n  }\n\n  delegatedAccount(delegator: Address): LogicSigAccount {\n    return new LogicSigAccount(this.logic, this.args, delegator)\n  }\n}\n\nexport class LogicSigAccount extends LogicSig {\n  sig?: Uint8Array\n  msig?: MultisigSignature\n  lmsig?: MultisigSignature\n\n  static fromSignature(signature: LogicSigSignature, delegator?: Address): LogicSigAccount {\n    if (signature.lmsig || signature.msig) {\n      const msigAddr = MultisigAccount.fromSignature((signature.lmsig || signature.msig)!).addr\n\n      if (delegator && !msigAddr.equals(delegator)) {\n        throw new Error('Provided delegator address does not match multisig address')\n      }\n\n      const lsig = new LogicSigAccount(signature.logic, signature.args || [], msigAddr)\n      lsig.lmsig = signature.lmsig\n      lsig.msig = signature.msig\n      return lsig\n    }\n\n    const lsigAccount = new LogicSigAccount(signature.logic, signature.args || [], delegator)\n\n    if (signature.sig && delegator === undefined) {\n      throw new Error('Delegated address must be provided when logic sig has a signature')\n    }\n\n    if (signature.sig) {\n      lsigAccount.sig = signature.sig\n      return lsigAccount\n    }\n\n    return lsigAccount\n  }\n\n  static fromBytes(encodedLsig: Uint8Array, delegator?: Address): LogicSigAccount {\n    const decoded = decodeMsgpack(encodedLsig)\n    const lsigSignature = logicSigSignatureCodec.decode(decoded, 'msgpack')\n    return LogicSigAccount.fromSignature(lsigSignature, delegator)\n  }\n\n  constructor(program: Uint8Array, programArgs?: Array<Uint8Array> | null, delegator?: Address) {\n    super(program, programArgs ?? undefined)\n    this._addr = delegator ?? this._addr\n  }\n\n  get signer(): TransactionSigner {\n    return async (txns: Transaction[], indexes: number[]) => {\n      const signedTxns: Uint8Array[] = []\n      for (const index of indexes) {\n        const txn = txns[index]\n\n        const stxn: SignedTransaction = {\n          txn,\n          lsig: { logic: this.logic, args: this.args, msig: this.msig, lmsig: this.lmsig, sig: this.sig },\n        }\n\n        if (!stxn.txn.sender.equals(this.addr)) {\n          stxn.authAddress = this.addr\n        }\n\n        validateSignedTransaction(stxn)\n        signedTxns.push(encodeSignedTransaction(stxn))\n      }\n\n      return signedTxns\n    }\n  }\n\n  async signForDelegation(delegator: AddressWithDelegatedLsigSigner) {\n    const result = await delegator.lsigSigner(this)\n\n    if (!result.addr.equals(this._addr)) {\n      throw new Error(\n        `Delegator address from signer does not match expected delegator address. Expected: ${this._addr.toString()}, got: ${result.addr.toString()}`,\n      )\n    }\n\n    if ('sig' in result && result.sig) {\n      this.sig = result.sig\n    } else if ('lmsig' in result && result.lmsig) {\n      this.lmsig = result.lmsig\n    } else {\n      throw new Error('Delegated lsig signer must return either a sig or lmsig')\n    }\n  }\n}\n"],"mappings":"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"}

package/packages/transact/src/multisig.d.ts

@@ -1,115 +1,10 @@
 import { Address } from "../../common/src/address.js";
 import { Transaction } from "./transactions/transaction.js";
-import { MultisigSignature } from "./transactions/signed-transaction.js";
+import { MultisigSignature, SignedTransaction } from "./transactions/signed-transaction.js";
+import { DelegatedLsigSigner } from "./logicsig.js";
 import { AddressWithDelegatedLsigSigner, AddressWithTransactionSigner, TransactionSigner } from "./signer.js";
 
 //#region packages/transact/src/multisig.d.ts
-
-/**
- * Creates an empty multisignature signature from a list of participant public keys.
- */
-declare function newMultisigSignature(version: number, threshold: number, participants: Uint8Array[]): MultisigSignature;
-/**
- * Returns the list of participant public keys from a multisignature signature.
- */
-declare function participantsFromMultisigSignature(multisigSignature: MultisigSignature): Uint8Array[];
-/**
- * Returns the address of the multisignature account.
- */
-declare function addressFromMultisigSignature(multisigSignature: MultisigSignature): Address;
-/**
- * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature.
- *
- * This method applies the signature to ALL instances of the given public key (to support weighted multisig).
- * Since ed25519 signatures are deterministic, there's only one valid signature for a given message and public key.
- */
-declare function applyMultisigSubsignature(multisigSignature: MultisigSignature, participant: Uint8Array, signature: Uint8Array): MultisigSignature;
-/**
- * Merges two multisignature signatures, replacing signatures in the first with those from the second where present.
- * For each participant, the resulting signature will be taken from the second multisig if present, otherwise from the first.
- */
-declare function mergeMultisignatures(multisigSignatureA: MultisigSignature, multisigSignatureB: MultisigSignature): MultisigSignature;
-declare const MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = "Not enough multisig transactions to merge. Need at least two";
-declare const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
-declare const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
-declare const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
-declare const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
-declare const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
-declare const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
-declare const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
-/**
- * creates a raw, multisig transaction blob without any signatures.
- * @param txn - the actual transaction.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param pks - ordered list of public keys in this multisig
- * @returns encoded multisig blob
- */
-declare function createMultisigTransaction(txn: Transaction, {
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata): Uint8Array;
-/**
- * takes a list of multisig transaction blobs, and merges them.
- * @param multisigTxnBlobs - a list of blobs representing encoded multisig txns
- * @returns typed array msg-pack encoded multisig txn
- */
-declare function mergeMultisigTransactions(multisigTxnBlobs: Uint8Array[]): Uint8Array;
-/**
- * Takes a multisig transaction blob, and appends a given raw signature to it.
- * This makes it possible to compile a multisig signature using only raw signatures from external methods.
- * @param multisigTxnBlob - an encoded multisig txn. Supports non-payment txn types.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - a list of Algorand addresses representing possible signers for this multisig. Order is important.
- * @param signerAddr - address of the signer
- * @param signature - raw multisig signature
- * @returns object containing txID, and blob representing encoded multisig txn
- */
-declare function appendSignRawMultisigSignature(multisigTxnBlob: Uint8Array, {
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata, signerAddr: string | Address, signature: Uint8Array): {
-  txID: string;
-  blob: Uint8Array;
-};
-/**
- * Takes multisig parameters and returns a 32 byte typed array public key,
- * representing an address that identifies the "exact group, version, and public keys" that are required for signing.
- * Hash("MultisigAddr" || version uint8 || threshold uint8 || PK1 || PK2 || ...)
- * Encoding this output yields a human readable address.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param pks - array of typed array public keys
- */
-declare function addressFromMultisigPreImg({
-  version,
-  threshold,
-  pks
-}: Omit<MultisigMetadata, 'addrs'> & {
-  pks: Uint8Array[];
-}): Address;
-/**
- * Takes multisig parameters and returns a human readable Algorand address.
- * This is equivalent to fromMultisigPreImg, but interfaces with encoded addresses.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - array of encoded addresses
- */
-declare function addressFromMultisigPreImgAddrs({
-  version,
-  threshold,
-  addrs
-}: MultisigMetadata): Address;
-/**
- * Takes multisig metadata (preimage) and returns the corresponding human readable Algorand address.
- * @param version - multisig version
- * @param threshold - multisig threshold
- * @param addrs - list of Algorand addresses
- */
-declare const multisigAddress: typeof addressFromMultisigPreImgAddrs;
 interface MultisigMetadata {
   /**
    * Multisig version
@@ -126,11 +21,12 @@ interface MultisigMetadata {
   addrs: Array<Address>;
 }
 /** Account wrapper that supports partial or full multisig signing. */
-declare class MultisigAccount implements AddressWithTransactionSigner {
+declare class MultisigAccount implements AddressWithTransactionSigner, AddressWithDelegatedLsigSigner {
   _params: MultisigMetadata;
   _subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[];
   _addr: Address;
   _signer: TransactionSigner;
+  _lsigSigner: DelegatedLsigSigner;
   /** The parameters for the multisig account */
   get params(): Readonly<MultisigMetadata>;
   /** The list of accounts that are present to sign transactions or lsigs */
@@ -139,15 +35,14 @@ declare class MultisigAccount implements AddressWithTransactionSigner {
   get addr(): Readonly<Address>;
   /** The transaction signer for the multisig account */
   get signer(): TransactionSigner;
+  get lsigSigner(): DelegatedLsigSigner;
+  static fromSignature(signature: MultisigSignature): MultisigAccount;
   constructor(multisigParams: MultisigMetadata, subSigners: (AddressWithTransactionSigner & AddressWithDelegatedLsigSigner)[]);
+  createMultisigTransaction(txn: Transaction): SignedTransaction;
+  createMultisigSignature(): MultisigSignature;
+  applySignatureToTxn(txn: SignedTransaction, pubkey: Uint8Array, signature: Uint8Array): void;
+  applySignature(msigSignature: MultisigSignature, pubkey: Uint8Array, signature: Uint8Array): MultisigSignature;
 }
-/**
- * Decodes MsgPack bytes into a multi signature.
- *
- * @param encodedMultiSignature - The MsgPack encoded multi signature
- * @returns The decoded MultisigSignature or an error if decoding fails.
- */
-declare function decodeMultiSignature(encodedMultiSignature: Uint8Array): MultisigSignature;
 //#endregion
-export { MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG, MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG, MULTISIG_MERGE_MISMATCH_ERROR_MSG, MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG, MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG, MULTISIG_NO_MUTATE_ERROR_MSG, MULTISIG_SIGNATURE_LENGTH_ERROR_MSG, MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG, MultisigAccount, MultisigMetadata, addressFromMultisigPreImg, addressFromMultisigPreImgAddrs, addressFromMultisigSignature, appendSignRawMultisigSignature, applyMultisigSubsignature, createMultisigTransaction, decodeMultiSignature, mergeMultisigTransactions, mergeMultisignatures, multisigAddress, newMultisigSignature, participantsFromMultisigSignature };
+export { MultisigAccount, MultisigMetadata };
 //# sourceMappingURL=multisig.d.ts.map

package/packages/transact/src/multisig.js

@@ -2,42 +2,11 @@ const require_array = require('../../common/src/array.js');
 const require_constants = require('../../common/src/constants.js');
 const require_address = require('../../common/src/address.js');
 const require_crypto = require('../../common/src/crypto.js');
-const require_msgpack = require('../../common/src/msgpack.js');
-const require_signed_transaction_meta = require('./transactions/signed-transaction-meta.js');
 const require_signed_transaction = require('./transactions/signed-transaction.js');
 
 //#region packages/transact/src/multisig.ts
-/**
-* Creates an empty multisignature signature from a list of participant public keys.
-*/
-function newMultisigSignature(version, threshold, participants) {
-	if (version === 0) throw new Error("Version cannot be zero");
-	if (participants.length === 0) throw new Error("Participants cannot be empty");
-	if (threshold === 0 || threshold > participants.length) throw new Error("Threshold must be greater than zero and less than or equal to the number of participants");
-	return {
-		version,
-		threshold,
-		subsignatures: participants.map((publicKey) => ({ publicKey }))
-	};
-}
-/**
-* Returns the list of participant public keys from a multisignature signature.
-*/
-function participantsFromMultisigSignature(multisigSignature) {
-	return multisigSignature.subsignatures.map((subsig) => subsig.publicKey);
-}
 const toPublicKeys = (addrs) => addrs.map((addr) => require_address.getAddress(addr).publicKey);
 /**
-* Returns the address of the multisignature account.
-*/
-function addressFromMultisigSignature(multisigSignature) {
-	return addressFromMultisigPreImg({
-		version: multisigSignature.version,
-		threshold: multisigSignature.threshold,
-		pks: multisigSignature.subsignatures.map((subsig) => subsig.publicKey)
-	});
-}
-/**
 * Applies a subsignature for a participant to a multisignature signature, replacing any existing signature.
 *
 * This method applies the signature to ALL instances of the given public key (to support weighted multisig).
@@ -45,12 +14,12 @@ function addressFromMultisigSignature(multisigSignature) {
 */
 function applyMultisigSubsignature(multisigSignature, participant, signature) {
 	let found = false;
-	const newSubsignatures = multisigSignature.subsignatures.map((subsig) => {
+	const newSubsignatures = multisigSignature.subsigs.map((subsig) => {
 		if (require_array.arrayEqual(subsig.publicKey, participant)) {
 			found = true;
 			return {
 				...subsig,
-				signature
+				sig: signature
 			};
 		}
 		return subsig;
@@ -58,30 +27,7 @@ function applyMultisigSubsignature(multisigSignature, participant, signature) {
 	if (!found) throw new Error("Public key not found in multisig signature");
 	return {
 		...multisigSignature,
-		subsignatures: newSubsignatures
-	};
-}
-/**
-* Merges two multisignature signatures, replacing signatures in the first with those from the second where present.
-* For each participant, the resulting signature will be taken from the second multisig if present, otherwise from the first.
-*/
-function mergeMultisignatures(multisigSignatureA, multisigSignatureB) {
-	if (multisigSignatureA.version !== multisigSignatureB.version) throw new Error("Cannot merge multisig signatures with different versions");
-	if (multisigSignatureA.threshold !== multisigSignatureB.threshold) throw new Error("Cannot merge multisig signatures with different thresholds");
-	const participantsA = participantsFromMultisigSignature(multisigSignatureA);
-	const participantsB = participantsFromMultisigSignature(multisigSignatureB);
-	if (!(participantsA.length === participantsB.length && participantsA.every((pk, i) => require_array.arrayEqual(pk, participantsB[i])))) throw new Error("Cannot merge multisig signatures with different participants");
-	const mergedSubsignatures = multisigSignatureA.subsignatures.map((s1, index) => {
-		const s2 = multisigSignatureB.subsignatures[index];
-		return {
-			publicKey: s1.publicKey,
-			signature: s2.signature || s1.signature
-		};
-	});
-	return {
-		version: multisigSignatureA.version,
-		threshold: multisigSignatureA.threshold,
-		subsignatures: mergedSubsignatures
+		subsigs: newSubsignatures
 	};
 }
 const MULTISIG_PREIMG2ADDR_PREFIX = new Uint8Array([
@@ -107,8 +53,6 @@ const MULTISIG_MERGE_MISMATCH_ERROR_MSG = "Cannot merge txs. txIDs differ";
 const MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = "Cannot merge txs. Auth addrs differ";
 const MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = "Cannot merge txs. Multisig preimages differ";
 const MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = "Cannot merge txs. subsigs are mismatched.";
-const MULTISIG_NO_MUTATE_ERROR_MSG = "Cannot mutate a multisig field as it would invalidate all existing signatures.";
-const MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = "Cannot sign a multisig transaction using `signTxn`. Use `partialSignTxn` instead.";
 const MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = "Cannot add multisig signature. Signature is not of the correct length.";
 const MULTISIG_KEY_NOT_EXIST_ERROR_MSG = "Key does not exist";
 /**
@@ -124,23 +68,23 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 	const msig = {
 		version,
 		threshold,
-		subsignatures: pks.map((pk) => ({
+		subsigs: pks.map((pk) => ({
 			publicKey: pk,
-			signature: void 0
+			sig: void 0
 		}))
 	};
 	const msigAddr = addressFromMultisigPreImg({
 		version,
 		threshold,
-		pks
+		publicKeys: pks
 	});
 	let authAddress;
 	if (!msigAddr.equals(txn.sender)) authAddress = msigAddr;
-	return require_signed_transaction.encodeSignedTransaction({
+	return {
 		txn,
 		msig,
 		authAddress
-	});
+	};
 }
 /**
 * creates a multisig transaction blob with an included signature.
@@ -152,31 +96,31 @@ function createMultisigTransaction(txn, { version, threshold, addrs }) {
 * @param pks - ordered list of public keys in this multisig
 * @returns encoded multisig blob
 */
-function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version, threshold, pks }) {
-	const signedTxn = require_signed_transaction.decodeSignedTransaction(createMultisigTransaction(txn, {
+function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version, threshold, publicKeys }) {
+	const signedTxn = createMultisigTransaction(txn, {
 		version,
 		threshold,
-		addrs: pks.map((pk) => new require_address.Address(pk))
-	}));
+		addrs: publicKeys.map((pk) => new require_address.Address(pk))
+	});
 	let keyExist = false;
-	const updatedSubsigs = signedTxn.msig.subsignatures.map((subsig) => {
+	const updatedSubsigs = signedTxn.msig.subsigs.map((subsig) => {
 		if (require_array.arrayEqual(subsig.publicKey, myPk)) {
 			keyExist = true;
 			return {
 				...subsig,
-				signature: rawSig
+				sig: rawSig
 			};
 		}
 		return subsig;
 	});
 	if (!keyExist) throw new Error(MULTISIG_KEY_NOT_EXIST_ERROR_MSG);
-	return require_signed_transaction.encodeSignedTransaction({
+	return {
 		...signedTxn,
 		msig: {
 			...signedTxn.msig,
-			subsignatures: updatedSubsigs
+			subsigs: updatedSubsigs
 		}
-	});
+	};
 }
 /**
 * takes a list of multisig transaction blobs, and merges them.
@@ -185,44 +129,44 @@ function createMultisigTransactionWithSignature(txn, { rawSig, myPk }, { version
 */
 function mergeMultisigTransactions(multisigTxnBlobs) {
 	if (multisigTxnBlobs.length < 2) throw new Error(MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG);
-	const refSigTx = require_signed_transaction.decodeSignedTransaction(multisigTxnBlobs[0]);
+	const refSigTx = multisigTxnBlobs[0];
 	if (!refSigTx.msig) throw new Error("Invalid multisig transaction, multisig structure missing at index 0");
 	const refTxID = refSigTx.txn.txId();
 	const refAuthAddr = refSigTx.authAddress;
 	const refMsigAddr = addressFromMultisigPreImg({
 		version: refSigTx.msig.version,
 		threshold: refSigTx.msig.threshold,
-		pks: refSigTx.msig.subsignatures.map((subsig) => subsig.publicKey)
+		publicKeys: refSigTx.msig.subsigs.map((subsig) => subsig.publicKey)
 	});
-	const newSubsigs = refSigTx.msig.subsignatures.map((sig) => ({ ...sig }));
+	const newSubsigs = refSigTx.msig.subsigs.map((sig) => ({ ...sig }));
 	for (let i = 1; i < multisigTxnBlobs.length; i++) {
-		const unisig = require_signed_transaction.decodeSignedTransaction(multisigTxnBlobs[i]);
+		const unisig = multisigTxnBlobs[i];
 		if (!unisig.msig) throw new Error(`Invalid multisig transaction, multisig structure missing at index ${i}`);
 		if (unisig.txn.txId() !== refTxID) throw new Error(MULTISIG_MERGE_MISMATCH_ERROR_MSG);
 		if (refAuthAddr !== unisig.authAddress) throw new Error(MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG);
-		if (unisig.msig.subsignatures.length !== refSigTx.msig.subsignatures.length) throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
+		if (unisig.msig.subsigs.length !== refSigTx.msig.subsigs.length) throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
 		const msgigAddr = addressFromMultisigPreImg({
 			version: unisig.msig.version,
 			threshold: unisig.msig.threshold,
-			pks: unisig.msig.subsignatures.map((subsig) => subsig.publicKey)
+			publicKeys: unisig.msig.subsigs.map((subsig) => subsig.publicKey)
 		});
 		if (refMsigAddr.toString() !== msgigAddr.toString()) throw new Error(MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG);
-		unisig.msig.subsignatures.forEach((uniSubsig, index) => {
-			if (!uniSubsig.signature) return;
+		unisig.msig.subsigs.forEach((uniSubsig, index) => {
+			if (!uniSubsig.sig) return;
 			const current = newSubsigs[index];
-			if (current.signature && !require_array.arrayEqual(uniSubsig.signature, current.signature)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
-			current.signature = uniSubsig.signature;
+			if (current.sig && !require_array.arrayEqual(uniSubsig.sig, current.sig)) throw new Error(MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG);
+			current.sig = uniSubsig.sig;
 		});
 	}
-	return require_signed_transaction.encodeSignedTransaction({
+	return {
 		txn: refSigTx.txn,
 		msig: {
 			version: refSigTx.msig.version,
 			threshold: refSigTx.msig.threshold,
-			subsignatures: newSubsigs
+			subsigs: newSubsigs
 		},
 		authAddress: refAuthAddr
-	});
+	};
 }
 /**
 * Partially signs this transaction with an external raw multisig signature and returns
@@ -251,18 +195,13 @@ function partialSignWithMultisigSignature(transaction, metadata, signerAddr, sig
 * @param signature - raw multisig signature
 * @returns object containing txID, and blob representing encoded multisig txn
 */
-function appendSignRawMultisigSignature(multisigTxnBlob, { version, threshold, addrs }, signerAddr, signature) {
-	const pks = toPublicKeys(addrs);
-	const multisigTxObj = require_signed_transaction.decodeSignedTransaction(multisigTxnBlob);
-	const partialSignedBlob = partialSignWithMultisigSignature(multisigTxObj.txn, {
+function appendSignRawMultisigSignature(multisigTxn, { version, threshold, addrs }, signerAddr, signature) {
+	const publicKeys = toPublicKeys(addrs);
+	return mergeMultisigTransactions([multisigTxn, partialSignWithMultisigSignature(multisigTxn.txn, {
 		version,
 		threshold,
-		pks
-	}, signerAddr, signature);
-	return {
-		txID: multisigTxObj.txn.txId(),
-		blob: mergeMultisigTransactions([multisigTxnBlob, partialSignedBlob])
-	};
+		publicKeys
+	}, signerAddr, signature)]);
 }
 /**
 * Takes multisig parameters and returns a 32 byte typed array public key,
@@ -273,18 +212,18 @@ function appendSignRawMultisigSignature(multisigTxnBlob, { version, threshold, a
 * @param threshold - multisig threshold
 * @param pks - array of typed array public keys
 */
-function addressFromMultisigPreImg({ version, threshold, pks }) {
+function addressFromMultisigPreImg({ version, threshold, publicKeys }) {
 	if (version > 255 || version < 0) throw new Error(`${INVALID_MSIG_VERSION_ERROR_MSG}: ${version}`);
-	if (threshold === 0 || pks.length === 0 || threshold > pks.length || threshold > 255) throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG);
+	if (threshold === 0 || publicKeys.length === 0 || threshold > publicKeys.length || threshold > 255) throw new Error(INVALID_MSIG_THRESHOLD_ERROR_MSG);
 	const pkLen = require_address.ALGORAND_ADDRESS_BYTE_LENGTH - require_address.ALGORAND_CHECKSUM_BYTE_LENGTH;
 	if (pkLen !== require_constants.PUBLIC_KEY_BYTE_LENGTH) throw new Error(UNEXPECTED_PK_LEN_ERROR_MSG);
-	const merged = new Uint8Array(MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * pks.length);
+	const merged = new Uint8Array(MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + pkLen * publicKeys.length);
 	merged.set(MULTISIG_PREIMG2ADDR_PREFIX, 0);
 	merged.set([version], MULTISIG_PREIMG2ADDR_PREFIX.length);
 	merged.set([threshold], MULTISIG_PREIMG2ADDR_PREFIX.length + 1);
-	for (let i = 0; i < pks.length; i++) {
-		if (pks[i].length !== pkLen) throw new Error(INVALID_MSIG_PK_ERROR_MSG);
-		merged.set(pks[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen);
+	for (let i = 0; i < publicKeys.length; i++) {
+		if (publicKeys[i].length !== pkLen) throw new Error(INVALID_MSIG_PK_ERROR_MSG);
+		merged.set(publicKeys[i], MULTISIG_PREIMG2ADDR_PREFIX.length + 2 + i * pkLen);
 	}
 	return new require_address.Address(Uint8Array.from(require_crypto.hash(merged)));
 }
@@ -299,7 +238,7 @@ function addressFromMultisigPreImgAddrs({ version, threshold, addrs }) {
 	return addressFromMultisigPreImg({
 		version,
 		threshold,
-		pks: toPublicKeys(addrs)
+		publicKeys: toPublicKeys(addrs)
 	});
 }
 /**
@@ -310,11 +249,12 @@ function addressFromMultisigPreImgAddrs({ version, threshold, addrs }) {
 */
 const multisigAddress = addressFromMultisigPreImgAddrs;
 /** Account wrapper that supports partial or full multisig signing. */
-var MultisigAccount = class {
+var MultisigAccount = class MultisigAccount {
 	_params;
 	_subSigners;
 	_addr;
 	_signer;
+	_lsigSigner;
 	/** The parameters for the multisig account */
 	get params() {
 		return this._params;
@@ -331,6 +271,16 @@ var MultisigAccount = class {
 	get signer() {
 		return this._signer;
 	}
+	get lsigSigner() {
+		return this._lsigSigner;
+	}
+	static fromSignature(signature) {
+		return new MultisigAccount({
+			version: signature.version,
+			threshold: signature.threshold,
+			addrs: signature.subsigs.map((subsig) => new require_address.Address(subsig.publicKey))
+		}, []);
+	}
 	constructor(multisigParams, subSigners) {
 		this._params = multisigParams;
 		this._subSigners = subSigners;
@@ -344,45 +294,65 @@ var MultisigAccount = class {
 					const stxn = (await subSigner.signer([txn], [0]))[0];
 					const sig = require_signed_transaction.decodeSignedTransaction(stxn).sig;
 					if (!sig) throw new Error(`Signer for address ${subSigner.addr.toString()} did not produce a valid signature when signing ${txn.txId()} for multisig account ${this._addr.toString()}`);
-					signedMsigTxn = appendSignRawMultisigSignature(signedMsigTxn, this._params, subSigner.addr, sig).blob;
+					signedMsigTxn = appendSignRawMultisigSignature(signedMsigTxn, this._params, subSigner.addr, sig);
 				}
 				signedMsigTxns.push(signedMsigTxn);
 			}
-			return signedMsigTxns;
+			return signedMsigTxns.map((stxn) => {
+				require_signed_transaction.validateSignedTransaction(stxn);
+				return require_signed_transaction.encodeSignedTransaction(stxn);
+			});
+		};
+		this._lsigSigner = async (lsig, _) => {
+			let lmsig = lsig.lmsig ?? this.createMultisigSignature();
+			for (const addrWithSigner of this.subSigners) {
+				const { lsigSigner, addr } = addrWithSigner;
+				const result = await lsigSigner(lsig, this);
+				if (!("sig" in result) || !result.sig) throw new Error(`Signer for address ${addr.toString()} did not produce a valid signature when signing logic sig for multisig account ${this._addr.toString()}`);
+				lmsig = this.applySignature(lmsig, addr.publicKey, result.sig);
+			}
+			return {
+				addr: this.addr,
+				lmsig
+			};
 		};
 	}
+	createMultisigTransaction(txn) {
+		return createMultisigTransaction(txn, this._params);
+	}
+	createMultisigSignature() {
+		const subsignatures = toPublicKeys(this._params.addrs).map((pk) => ({
+			publicKey: pk,
+			sig: void 0
+		}));
+		return {
+			version: this._params.version,
+			threshold: this._params.threshold,
+			subsigs: subsignatures
+		};
+	}
+	applySignatureToTxn(txn, pubkey, signature) {
+		if (!txn.msig) txn.msig = this.createMultisigTransaction(txn.txn).msig;
+		txn.msig = applyMultisigSubsignature(txn.msig, pubkey, signature);
+	}
+	applySignature(msigSignature, pubkey, signature) {
+		if (msigSignature.version !== this._params.version || msigSignature.threshold !== this._params.threshold) {
+			const thisParams = {
+				version: this._params.version,
+				threshold: this._params.threshold,
+				participants: this._params.addrs.map((addr) => addr.toString())
+			};
+			const givenParams = {
+				version: msigSignature.version,
+				threshold: msigSignature.threshold,
+				participants: msigSignature.subsigs.map((subsig) => new require_address.Address(subsig.publicKey).toString())
+			};
+			throw new Error(`Multisig signature parameters do not match expected multisig parameters. Multisig params: ${JSON.stringify(thisParams)}, signature: ${JSON.stringify(givenParams)}`);
+		}
+		return applyMultisigSubsignature(msigSignature, pubkey, signature);
+	}
 };
-/**
-* Decodes MsgPack bytes into a multi signature.
-*
-* @param encodedMultiSignature - The MsgPack encoded multi signature
-* @returns The decoded MultisigSignature or an error if decoding fails.
-*/
-function decodeMultiSignature(encodedMultiSignature) {
-	const decodedData = require_msgpack.decodeMsgpack(encodedMultiSignature);
-	return require_signed_transaction_meta.multiSignatureCodec.decode(decodedData, "msgpack");
-}
 
 //#endregion
-exports.MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG = MULTISIG_MERGE_LESSTHANTWO_ERROR_MSG;
-exports.MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG = MULTISIG_MERGE_MISMATCH_AUTH_ADDR_MSG;
-exports.MULTISIG_MERGE_MISMATCH_ERROR_MSG = MULTISIG_MERGE_MISMATCH_ERROR_MSG;
-exports.MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG = MULTISIG_MERGE_SIG_MISMATCH_ERROR_MSG;
-exports.MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG = MULTISIG_MERGE_WRONG_PREIMAGE_ERROR_MSG;
-exports.MULTISIG_NO_MUTATE_ERROR_MSG = MULTISIG_NO_MUTATE_ERROR_MSG;
-exports.MULTISIG_SIGNATURE_LENGTH_ERROR_MSG = MULTISIG_SIGNATURE_LENGTH_ERROR_MSG;
-exports.MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG = MULTISIG_USE_PARTIAL_SIGN_ERROR_MSG;
 exports.MultisigAccount = MultisigAccount;
-exports.addressFromMultisigPreImg = addressFromMultisigPreImg;
-exports.addressFromMultisigPreImgAddrs = addressFromMultisigPreImgAddrs;
-exports.addressFromMultisigSignature = addressFromMultisigSignature;
-exports.appendSignRawMultisigSignature = appendSignRawMultisigSignature;
-exports.applyMultisigSubsignature = applyMultisigSubsignature;
-exports.createMultisigTransaction = createMultisigTransaction;
-exports.decodeMultiSignature = decodeMultiSignature;
-exports.mergeMultisigTransactions = mergeMultisigTransactions;
-exports.mergeMultisignatures = mergeMultisignatures;
-exports.multisigAddress = multisigAddress;
-exports.newMultisigSignature = newMultisigSignature;
-exports.participantsFromMultisigSignature = participantsFromMultisigSignature;
 //# sourceMappingURL=multisig.js.map