@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-55NODGHC.mjs

@@ -1,135 +0,0 @@
-import {
-  getInfo
-} from "./chunk-Y2LV3S5W.mjs";
-import {
-  sleep
-} from "./chunk-GGMTQAQP.mjs";
-
-// src/transactions/management/accountSequenceNumber.ts
-var now = () => Math.floor(Date.now() / 1e3);
-var AccountSequenceNumber = class {
-  constructor(aptosConfig, account, maxWaitTime, maximumInFlight, sleepTime) {
-    // sequence number on chain
-    this.lastUncommintedNumber = null;
-    // local sequence number
-    this.currentNumber = null;
-    /**
-     * We want to guarantee that we preserve ordering of workers to requests.
-     *
-     * `lock` is used to try to prevent multiple coroutines from accessing a shared resource at the same time,
-     * which can result in race conditions and data inconsistency.
-     * This code actually doesn't do it though, since we aren't giving out a slot, it is still somewhat a race condition.
-     *
-     * The ideal solution is likely that each thread grabs the next number from a incremental integer.
-     * When they complete, they increment that number and that entity is able to enter the `lock`.
-     * That would guarantee ordering.
-     */
-    this.lock = false;
-    this.aptosConfig = aptosConfig;
-    this.account = account;
-    this.maxWaitTime = maxWaitTime;
-    this.maximumInFlight = maximumInFlight;
-    this.sleepTime = sleepTime;
-  }
-  /**
-   * Returns the next available sequence number for this account
-   *
-   * @returns next available sequence number
-   */
-  async nextSequenceNumber() {
-    while (this.lock) {
-      await sleep(this.sleepTime);
-    }
-    this.lock = true;
-    let nextNumber = BigInt(0);
-    try {
-      if (this.lastUncommintedNumber === null || this.currentNumber === null) {
-        await this.initialize();
-      }
-      if (this.currentNumber - this.lastUncommintedNumber >= this.maximumInFlight) {
-        await this.update();
-        const startTime = now();
-        while (this.currentNumber - this.lastUncommintedNumber >= this.maximumInFlight) {
-          await sleep(this.sleepTime);
-          if (now() - startTime > this.maxWaitTime) {
-            console.warn(
-              `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`
-            );
-            await this.initialize();
-          } else {
-            await this.update();
-          }
-        }
-      }
-      nextNumber = this.currentNumber;
-      this.currentNumber += BigInt(1);
-    } catch (e) {
-      console.error("error in getting next sequence number for this account", e);
-    } finally {
-      this.lock = false;
-    }
-    return nextNumber;
-  }
-  /**
-   * Initializes this account with the sequence number on chain
-   */
-  async initialize() {
-    const { sequence_number: sequenceNumber } = await getInfo({
-      aptosConfig: this.aptosConfig,
-      accountAddress: this.account.accountAddress
-    });
-    this.currentNumber = BigInt(sequenceNumber);
-    this.lastUncommintedNumber = BigInt(sequenceNumber);
-  }
-  /**
-   * Updates this account sequence number with the one on-chain
-   *
-   * @returns on-chain sequence number for this account
-   */
-  async update() {
-    const { sequence_number: sequenceNumber } = await getInfo({
-      aptosConfig: this.aptosConfig,
-      accountAddress: this.account.accountAddress
-    });
-    this.lastUncommintedNumber = BigInt(sequenceNumber);
-    return this.lastUncommintedNumber;
-  }
-  /**
-   * Synchronizes local sequence number with the seqeunce number on chain for this account.
-   *
-   * Poll the network until all submitted transactions have either been committed or until
-   * the maximum wait time has elapsed
-   */
-  async synchronize() {
-    if (this.lastUncommintedNumber === this.currentNumber)
-      return;
-    while (this.lock) {
-      await sleep(this.sleepTime);
-    }
-    this.lock = true;
-    try {
-      await this.update();
-      const startTime = now();
-      while (this.lastUncommintedNumber !== this.currentNumber) {
-        if (now() - startTime > this.maxWaitTime) {
-          console.warn(
-            `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`
-          );
-          await this.initialize();
-        } else {
-          await sleep(this.sleepTime);
-          await this.update();
-        }
-      }
-    } catch (e) {
-      console.error("error in synchronizing this account sequence number with the one on chain", e);
-    } finally {
-      this.lock = false;
-    }
-  }
-};
-
-export {
-  AccountSequenceNumber
-};
-//# sourceMappingURL=chunk-55NODGHC.mjs.map

package/dist/esm/chunk-6LRQSBRH.mjs

@@ -1,130 +0,0 @@
-import {
-  KeylessAccount
-} from "./chunk-JV3GSIJW.mjs";
-import {
-  AccountAuthenticatorMultiKey
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  MultiKey,
-  MultiKeySignature
-} from "./chunk-WHBWEN6N.mjs";
-
-// src/account/MultiKeyAccount.ts
-var MultiKeyAccount = class _MultiKeyAccount {
-  /**
-   * constructor for MultiKeyAccount
-   *
-   * @param args.multiKey the multikey of the account which consists of N public keys and a number M which is
-   * the number of required signatures.
-   * @param args.signers an array of M signers that will be used to sign the transaction
-   * @returns MultiKeyAccount
-   */
-  constructor(args) {
-    const { multiKey, signers } = args;
-    this.publicKey = multiKey;
-    this.signingScheme = 3 /* MultiKey */;
-    this.accountAddress = this.publicKey.authKey().derivedAddress();
-    const bitPositions = [];
-    for (const signer of signers) {
-      bitPositions.push(this.publicKey.getIndex(signer.publicKey));
-    }
-    const signersAndBitPosition = signers.map((signer, index) => [signer, bitPositions[index]]);
-    signersAndBitPosition.sort((a, b) => a[1] - b[1]);
-    this.signers = signersAndBitPosition.map((value) => value[0]);
-    this.signerIndicies = signersAndBitPosition.map((value) => value[1]);
-    this.signaturesBitmap = this.publicKey.createBitmap({ bits: bitPositions });
-  }
-  /**
-   * Static constructor for MultiKeyAccount
-   *
-   * @param args.publicKeys the N public keys of the MultiKeyAccount
-   * @param args.signaturesRequired the number of signatures required
-   * @param args.signers an array of M signers that will be used to sign the transaction
-   * @returns MultiKeyAccount
-   */
-  static fromPublicKeysAndSigners(args) {
-    const { publicKeys, signaturesRequired, signers } = args;
-    const multiKey = new MultiKey({ publicKeys, signaturesRequired });
-    return new _MultiKeyAccount({ multiKey, signers });
-  }
-  static isMultiKeySigner(account) {
-    return account instanceof _MultiKeyAccount;
-  }
-  /**
-   * Sign a message using the account's signers.
-   * @param message the signing message, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
-   */
-  signWithAuthenticator(message) {
-    return new AccountAuthenticatorMultiKey(this.publicKey, this.sign(message));
-  }
-  /**
-   * Sign a transaction using the account's signers.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-   */
-  signTransactionWithAuthenticator(transaction) {
-    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
-  }
-  /**
-   * Waits for any proofs to be fetched
-   * @return
-   */
-  async waitForProofFetch() {
-    const keylessSigners = this.signers.filter((signer) => signer instanceof KeylessAccount);
-    await Promise.all(keylessSigners.filter((signer) => signer.proof instanceof Promise).map((signer) => signer.proof));
-  }
-  /**
-   * Sign the given message using the MultiKeyAccount's signers
-   * @param message in HexInput format
-   * @returns MultiKeySignature
-   */
-  sign(data) {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.sign(data));
-    }
-    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-  /**
-   * Sign the given transaction using the MultiKeyAccount's signers
-   * @param transaction the transaction to be signed
-   * @returns MultiKeySignature
-   */
-  signTransaction(transaction) {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.signTransaction(transaction));
-    }
-    return new MultiKeySignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-  /**
-   * Verify the given message and signature with the public key.
-   *
-   * @param args.message raw message data in HexInput format
-   * @param args.signatures signed message MultiKeySignature
-   * @returns boolean
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    const isSignerIndiciesSorted = this.signerIndicies.every(
-      (value, i) => i === 0 || value >= this.signerIndicies[i - 1]
-    );
-    if (!isSignerIndiciesSorted) {
-      return false;
-    }
-    for (let i = 0; i < signature.signatures.length; i += 1) {
-      const singleSignature = signature.signatures[i];
-      const publicKey = this.publicKey.publicKeys[this.signerIndicies[i]];
-      if (!publicKey.verifySignature({ message, signature: singleSignature })) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-export {
-  MultiKeyAccount
-};
-//# sourceMappingURL=chunk-6LRQSBRH.mjs.map

package/dist/esm/chunk-6MSZMIFW.mjs

@@ -1,23 +0,0 @@
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-
-// src/transactions/instances/chainId.ts
-var ChainId = class _ChainId extends Serializable {
-  constructor(chainId) {
-    super();
-    this.chainId = chainId;
-  }
-  serialize(serializer) {
-    serializer.serializeU8(this.chainId);
-  }
-  static deserialize(deserializer) {
-    const chainId = deserializer.deserializeU8();
-    return new _ChainId(chainId);
-  }
-};
-
-export {
-  ChainId
-};
-//# sourceMappingURL=chunk-6MSZMIFW.mjs.map

package/dist/esm/chunk-76TSTAU4.mjs

@@ -1,120 +0,0 @@
-// src/core/crypto/poseidon.ts
-import {
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-} from "poseidon-lite";
-var numInputsToPoseidonFunc = [
-  poseidon1,
-  poseidon2,
-  poseidon3,
-  poseidon4,
-  poseidon5,
-  poseidon6,
-  poseidon7,
-  poseidon8,
-  poseidon9,
-  poseidon10,
-  poseidon11,
-  poseidon12,
-  poseidon13,
-  poseidon14,
-  poseidon15,
-  poseidon16
-];
-var BYTES_PACKED_PER_SCALAR = 31;
-var MAX_NUM_INPUT_SCALARS = 16;
-var MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
-function hashASCIIStrToField(str, maxSizeBytes) {
-  const textEncoder = new TextEncoder();
-  const strBytes = textEncoder.encode(str);
-  return hashBytesWithLen(strBytes, maxSizeBytes);
-}
-function hashBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
-  return poseidonHash(packed);
-}
-function padAndPackBytesNoLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
-  return packBytes(paddedStrBytes);
-}
-function padAndPackBytesWithLen(bytes, maxSizeBytes) {
-  if (bytes.length > maxSizeBytes) {
-    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
-  }
-  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
-}
-function packBytes(bytes) {
-  if (bytes.length > MAX_NUM_INPUT_BYTES) {
-    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
-  }
-  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
-}
-function chunkUint8Array(array, chunkSize) {
-  const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.subarray(i, i + chunkSize));
-  }
-  return result;
-}
-function bytesToBigIntLE(bytes) {
-  let result = BigInt(0);
-  for (let i = bytes.length - 1; i >= 0; i -= 1) {
-    result = result << BigInt(8) | BigInt(bytes[i]);
-  }
-  return result;
-}
-function bigIntToBytesLE(value, length) {
-  const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i += 1) {
-    bytes[i] = Number(value & BigInt(255));
-    value >>= BigInt(8);
-  }
-  return bytes;
-}
-function padUint8ArrayWithZeros(inputArray, paddedSize) {
-  if (paddedSize < inputArray.length) {
-    throw new Error("Padded size must be greater than or equal to the input array size.");
-  }
-  const paddedArray = new Uint8Array(paddedSize);
-  paddedArray.set(inputArray);
-  for (let i = inputArray.length; i < paddedSize; i += 1) {
-    paddedArray[i] = 0;
-  }
-  return paddedArray;
-}
-function poseidonHash(inputs) {
-  const poseidonFixedHash = numInputsToPoseidonFunc[inputs.length - 1];
-  if (poseidonFixedHash) {
-    return poseidonFixedHash(inputs);
-  }
-  throw new Error(`Unable to hash input of length ${inputs.length}`);
-}
-
-export {
-  hashASCIIStrToField,
-  padAndPackBytesWithLen,
-  bytesToBigIntLE,
-  bigIntToBytesLE,
-  poseidonHash
-};
-//# sourceMappingURL=chunk-76TSTAU4.mjs.map