@solana/compat 2.0.0-experimental.fc4e943 → 2.0.0-experimental.fcff844

package/dist/index.development.js

@@ -2,22 +2,185 @@ this.globalThis = this.globalThis || {};
 this.globalThis.solanaWeb3 = (function (exports) {
   'use strict';
 
+  // src/address.ts
+  function fromLegacyPublicKey(publicKey) {
+    return publicKey.toBase58();
+  }
+
+  // ../codecs-core/dist/index.browser.js
+  function getEncodedSize(value, encoder) {
+    return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+  }
+  function createEncoder(encoder) {
+    return Object.freeze({
+      ...encoder,
+      encode: (value) => {
+        const bytes = new Uint8Array(getEncodedSize(value, encoder));
+        encoder.write(value, bytes, 0);
+        return bytes;
+      }
+    });
+  }
+
+  // ../codecs-strings/dist/index.browser.js
+  function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+    if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+      throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);
+    }
+  }
+  var getBaseXEncoder = (alphabet4) => {
+    return createEncoder({
+      getSizeFromValue: (value) => {
+        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+        if (tailChars === "")
+          return value.length;
+        const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+        return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+      },
+      write(value, bytes, offset) {
+        assertValidBaseString(alphabet4, value);
+        if (value === "")
+          return offset;
+        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+        if (tailChars === "") {
+          bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+          return offset + leadingZeroes.length;
+        }
+        let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+        const tailBytes = [];
+        while (base10Number > 0n) {
+          tailBytes.unshift(Number(base10Number % 256n));
+          base10Number /= 256n;
+        }
+        const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+        bytes.set(bytesToAdd, offset);
+        return offset + bytesToAdd.length;
+      }
+    });
+  };
+  function partitionLeadingZeroes(value, zeroCharacter) {
+    const leadingZeroIndex = [...value].findIndex((c) => c !== zeroCharacter);
+    return leadingZeroIndex === -1 ? [value, ""] : [value.slice(0, leadingZeroIndex), value.slice(leadingZeroIndex)];
+  }
+  function getBigIntFromBaseX(value, alphabet4) {
+    const base = BigInt(alphabet4.length);
+    return [...value].reduce((sum, char) => sum * base + BigInt(alphabet4.indexOf(char)), 0n);
+  }
+  var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+
+  // ../keys/dist/index.browser.js
+  function addPkcs8Header(bytes) {
+    return new Uint8Array([
+      /**
+       * PKCS#8 header
+       */
+      48,
+      // ASN.1 sequence tag
+      46,
+      // Length of sequence (46 more bytes)
+      2,
+      // ASN.1 integer tag
+      1,
+      // Length of integer
+      0,
+      // Version number
+      48,
+      // ASN.1 sequence tag
+      5,
+      // Length of sequence
+      6,
+      // ASN.1 object identifier tag
+      3,
+      // Length of object identifier
+      // Edwards curve algorithms identifier https://oid-rep.orange-labs.fr/get/1.3.101.112
+      43,
+      // iso(1) / identified-organization(3) (The first node is multiplied by the decimal 40 and the result is added to the value of the second node)
+      101,
+      // thawte(101)
+      // Ed25519 identifier
+      112,
+      // id-Ed25519(112)
+      /**
+       * Private key payload
+       */
+      4,
+      // ASN.1 octet string tag
+      34,
+      // String length (34 more bytes)
+      // Private key bytes as octet string
+      4,
+      // ASN.1 octet string tag
+      32,
+      // String length (32 bytes)
+      ...bytes
+    ]);
+  }
+  async function createPrivateKeyFromBytes(bytes, extractable) {
+    if (bytes.byteLength !== 32) {
+      throw new Error("Private key bytes must be of length 32");
+    }
+    const privateKeyBytesPkcs8 = addPkcs8Header(bytes);
+    return await crypto.subtle.importKey("pkcs8", privateKeyBytesPkcs8, "Ed25519", extractable != null ? extractable : false, ["sign"]);
+  }
+
+  // src/keypair.ts
+  async function fromLegacyKeypair(keypair, extractable) {
+    const [publicKey, privateKey] = await Promise.all([
+      crypto.subtle.importKey("raw", keypair.publicKey.toBytes(), "Ed25519", true, ["verify"]),
+      createPrivateKeyFromBytes(keypair.secretKey.slice(0, 32), extractable)
+    ]);
+    return {
+      privateKey,
+      publicKey
+    };
+  }
+
+  // ../addresses/dist/index.browser.js
+  var memoizedBase58Encoder;
+  function getMemoizedBase58Encoder() {
+    if (!memoizedBase58Encoder)
+      memoizedBase58Encoder = getBase58Encoder();
+    return memoizedBase58Encoder;
+  }
+  function assertIsAddress(putativeAddress) {
+    try {
+      if (
+        // Lowest address (32 bytes of zeroes)
+        putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+        putativeAddress.length > 44
+      ) {
+        throw new Error("Expected input string to decode to a byte array of length 32.");
+      }
+      const base58Encoder = getMemoizedBase58Encoder();
+      const bytes = base58Encoder.encode(putativeAddress);
+      const numBytes = bytes.byteLength;
+      if (numBytes !== 32) {
+        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
+      }
+    } catch (e2) {
+      throw new Error(`\`${putativeAddress}\` is not a base-58 encoded address`, {
+        cause: e2
+      });
+    }
+  }
+
   // ../functional/dist/index.browser.js
   function pipe(init, ...fns) {
     return fns.reduce((acc, fn) => fn(acc), init);
   }
 
   // ../instructions/dist/index.browser.js
-  var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
-    AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
+  var AccountRole = /* @__PURE__ */ ((AccountRole22) => {
+    AccountRole22[AccountRole22["WRITABLE_SIGNER"] = /* 3 */
     3] = "WRITABLE_SIGNER";
-    AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
+    AccountRole22[AccountRole22["READONLY_SIGNER"] = /* 2 */
     2] = "READONLY_SIGNER";
-    AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
+    AccountRole22[AccountRole22["WRITABLE"] = /* 1 */
     1] = "WRITABLE";
-    AccountRole2[AccountRole2["READONLY"] = /* 0 */
+    AccountRole22[AccountRole22["READONLY"] = /* 0 */
     0] = "READONLY";
-    return AccountRole2;
+    return AccountRole22;
   })(AccountRole || {});
 
   // ../transactions/dist/index.browser.js
@@ -54,6 +217,90 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Object.freeze(out);
     return out;
   }
+  var AccountRole2 = /* @__PURE__ */ ((AccountRole22) => {
+    AccountRole22[AccountRole22["WRITABLE_SIGNER"] = /* 3 */
+    3] = "WRITABLE_SIGNER";
+    AccountRole22[AccountRole22["READONLY_SIGNER"] = /* 2 */
+    2] = "READONLY_SIGNER";
+    AccountRole22[AccountRole22["WRITABLE"] = /* 1 */
+    1] = "WRITABLE";
+    AccountRole22[AccountRole22["READONLY"] = /* 0 */
+    0] = "READONLY";
+    return AccountRole22;
+  })(AccountRole2 || {});
+  function isSignerRole(role) {
+    return role >= 2;
+  }
+  var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
+  var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+  function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
+    return {
+      accounts: [
+        { address: nonceAccountAddress, role: AccountRole2.WRITABLE },
+        {
+          address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,
+          role: AccountRole2.READONLY
+        },
+        { address: nonceAuthorityAddress, role: AccountRole2.READONLY_SIGNER }
+      ],
+      data: new Uint8Array([4, 0, 0, 0]),
+      programAddress: SYSTEM_PROGRAM_ADDRESS
+    };
+  }
+  function isAdvanceNonceAccountInstruction(instruction) {
+    var _a;
+    return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
+    instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
+    ((_a = instruction.accounts) == null ? void 0 : _a.length) === 3 && // First account is nonce account address
+    instruction.accounts[0].address != null && instruction.accounts[0].role === AccountRole2.WRITABLE && // Second account is recent blockhashes sysvar
+    instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS && instruction.accounts[1].role === AccountRole2.READONLY && // Third account is nonce authority account
+    instruction.accounts[2].address != null && isSignerRole(instruction.accounts[2].role);
+  }
+  function isAdvanceNonceAccountInstructionData(data) {
+    return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
+  }
+  function isDurableNonceTransaction(transaction) {
+    return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
+  }
+  function isAdvanceNonceAccountInstructionForNonce(instruction, nonceAccountAddress, nonceAuthorityAddress) {
+    return instruction.accounts[0].address === nonceAccountAddress && instruction.accounts[2].address === nonceAuthorityAddress;
+  }
+  function setTransactionLifetimeUsingDurableNonce({
+    nonce,
+    nonceAccountAddress,
+    nonceAuthorityAddress
+  }, transaction) {
+    let newInstructions;
+    const firstInstruction = transaction.instructions[0];
+    if (firstInstruction && isAdvanceNonceAccountInstruction(firstInstruction)) {
+      if (isAdvanceNonceAccountInstructionForNonce(firstInstruction, nonceAccountAddress, nonceAuthorityAddress)) {
+        if (isDurableNonceTransaction(transaction) && transaction.lifetimeConstraint.nonce === nonce) {
+          return transaction;
+        } else {
+          newInstructions = [firstInstruction, ...transaction.instructions.slice(1)];
+        }
+      } else {
+        newInstructions = [
+          createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+          ...transaction.instructions.slice(1)
+        ];
+      }
+    } else {
+      newInstructions = [
+        createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+        ...transaction.instructions
+      ];
+    }
+    const out = {
+      ...getUnsignedTransaction(transaction),
+      instructions: newInstructions,
+      lifetimeConstraint: {
+        nonce
+      }
+    };
+    Object.freeze(out);
+    return out;
+  }
   function setTransactionFeePayer(feePayer, transaction) {
     if ("feePayer" in transaction && feePayer === transaction.feePayer) {
       return transaction;
@@ -121,7 +368,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
       throw new Error("No fee payer set in VersionedTransaction");
     const blockhashLifetime = {
       blockhash: transaction.message.recentBlockhash,
-      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
+      lastValidBlockHeight: lastValidBlockHeight != null ? lastValidBlockHeight : 2n ** 64n - 1n
       // U64 MAX
     };
     const instructions = transaction.message.compiledInstructions.map(
@@ -138,8 +385,48 @@ this.globalThis.solanaWeb3 = (function (exports) {
       (tx) => transaction.signatures.length ? { ...tx, signatures } : tx
     );
   }
+  function fromVersionedTransactionWithDurableNonce(transaction) {
+    if (transaction.message.addressTableLookups.length > 0) {
+      throw new Error("Cannot convert transaction with addressTableLookups");
+    }
+    const accountKeys = transaction.message.getAccountKeys();
+    const feePayer = accountKeys.staticAccountKeys[0];
+    if (!feePayer)
+      throw new Error("No fee payer set in VersionedTransaction");
+    const instructions = transaction.message.compiledInstructions.map(
+      (instruction) => convertInstruction(transaction.message, accountKeys, instruction)
+    );
+    if (instructions.length === 0) {
+      throw new Error("transaction with no instructions cannot be durable nonce transaction");
+    }
+    if (!isAdvanceNonceAccountInstruction(instructions[0])) {
+      throw new Error("transaction first instruction is not advance nonce account instruction");
+    }
+    const nonceAccountAddress = instructions[0].accounts[0].address;
+    assertIsAddress(nonceAccountAddress);
+    const nonceAuthorityAddress = instructions[0].accounts[2].address;
+    assertIsAddress(nonceAuthorityAddress);
+    const durableNonceLifetime = {
+      nonce: transaction.message.recentBlockhash,
+      nonceAccountAddress,
+      nonceAuthorityAddress
+    };
+    const signatures = convertSignatures(transaction, accountKeys.staticAccountKeys);
+    return pipe(
+      createTransaction({ version: transaction.version }),
+      (tx) => setTransactionFeePayer(feePayer.toBase58(), tx),
+      (tx) => setTransactionLifetimeUsingDurableNonce(durableNonceLifetime, tx),
+      (tx) => instructions.slice(1).reduce((acc, instruction) => {
+        return appendTransactionInstruction(instruction, acc);
+      }, tx),
+      (tx) => transaction.signatures.length ? { ...tx, signatures } : tx
+    );
+  }
 
+  exports.fromLegacyKeypair = fromLegacyKeypair;
+  exports.fromLegacyPublicKey = fromLegacyPublicKey;
   exports.fromVersionedTransactionWithBlockhash = fromVersionedTransactionWithBlockhash;
+  exports.fromVersionedTransactionWithDurableNonce = fromVersionedTransactionWithDurableNonce;
 
   return exports;