@anchor-lang/core 1.0.0-rc.2 → 1.0.0-rc.3

package/README.md

@@ -1,7 +1,7 @@
 # @anchor-lang/core
 
 [![npm](https://img.shields.io/npm/v/@anchor-lang/core.svg?color=blue)](https://www.npmjs.com/package/@anchor-lang/core)
-[![Docs](https://img.shields.io/badge/docs-typedoc-blue)](https://coral-xyz.github.io/anchor/ts/index.html)
+[![Docs](https://img.shields.io/badge/docs-typedoc-blue)](https://solana-foundation.github.io/anchor/ts/index.html)
 
 TypeScript client for Anchor programs.
 

package/dist/browser/index.js

@@ -5,10 +5,10 @@ import * as web3_js from '@solana/web3.js';
 export { web3_js as web3 };
 import { Buffer as Buffer$1 } from 'buffer';
 import bs58$1 from 'bs58';
+import { inflate, ungzip } from 'pako';
 import camelCase from 'camelcase';
 import * as borsh from '@anchor-lang/borsh';
 import { sha256 as sha256$1 } from '@noble/hashes/sha256';
-import { inflate } from 'pako';
 import EventEmitter from 'eventemitter3';
 
 /**
@@ -108,21 +108,117 @@ var index$1 = /*#__PURE__*/Object.freeze({
 function isCompositeAccounts(accountItem) {
     return "accounts" in accountItem;
 }
-// Deterministic IDL address as a function of the program id.
-async function idlAddress(programId) {
-    const base = (await PublicKey.findProgramAddress([], programId))[0];
-    return await PublicKey.createWithSeed(base, seed(), programId);
+// Account format defined at
+// https://github.com/solana-program/program-metadata/blob/734e947d/clients/js/src/generated/accounts/metadata.ts#L123-L138
+const PROGRAM_METADATA_PROGRAM_ID = new PublicKey("ProgM6JCCvbYkfKqJYHePx4xxSUSqJp7rh8Lyv7nk7S");
+const IDL_METADATA_SEED = "idl";
+const ACCOUNT_DISCRIMINATOR_METADATA = 2;
+const DATA_SOURCE_DIRECT = 0;
+// Only JSON formatted data is currently supported
+const FORMAT_JSON = 1;
+const SEED_SIZE = 16;
+const DATA_LENGTH_SIZE = 4;
+const DATA_LENGTH_PADDING = 5;
+const ZEROABLE_OPTION_PUBKEY_SIZE = 32;
+const METADATA_HEADER_SIZE = 1 + 32 + ZEROABLE_OPTION_PUBKEY_SIZE + 1 + 1 + SEED_SIZE + 1 + 1 + 1 + 1;
+var MetadataCompression;
+(function (MetadataCompression) {
+    MetadataCompression[MetadataCompression["None"] = 0] = "None";
+    MetadataCompression[MetadataCompression["Gzip"] = 1] = "Gzip";
+    MetadataCompression[MetadataCompression["Zlib"] = 2] = "Zlib";
+})(MetadataCompression || (MetadataCompression = {}));
+var MetadataEncoding;
+(function (MetadataEncoding) {
+    MetadataEncoding[MetadataEncoding["None"] = 0] = "None";
+    MetadataEncoding[MetadataEncoding["Utf8"] = 1] = "Utf8";
+    MetadataEncoding[MetadataEncoding["Base58"] = 2] = "Base58";
+    MetadataEncoding[MetadataEncoding["Base64"] = 3] = "Base64";
+})(MetadataEncoding || (MetadataEncoding = {}));
+function encodeMetadataSeed(seed) {
+    const encodedSeed = Buffer$1.from(encode$2(seed));
+    if (encodedSeed.length > SEED_SIZE) {
+        throw new Error(`Metadata seed '${seed}' exceeds ${SEED_SIZE} bytes`);
+    }
+    const paddedSeed = Buffer$1.alloc(SEED_SIZE);
+    encodedSeed.copy(paddedSeed);
+    return paddedSeed;
+}
+function idlAddress(programId) {
+    // Canonical metadata uses a null authority seed, which is serialized as `[]`.
+    return PublicKey.findProgramAddressSync([
+        programId.toBuffer(),
+        Buffer$1.alloc(0),
+        encodeMetadataSeed(IDL_METADATA_SEED),
+    ], PROGRAM_METADATA_PROGRAM_ID)[0];
 }
-// Seed for generating the idlAddress.
 function seed() {
-    return "anchor:idl";
+    return "idl";
 }
-const IDL_ACCOUNT_LAYOUT = borsh.struct([
-    borsh.publicKey("authority"),
-    borsh.vecU8("data"),
-]);
 function decodeIdlAccount(data) {
-    return IDL_ACCOUNT_LAYOUT.decode(data);
+    const minimumSize = METADATA_HEADER_SIZE + DATA_LENGTH_SIZE + DATA_LENGTH_PADDING;
+    if (data.length < minimumSize) {
+        throw new Error("Metadata account is too small");
+    }
+    let offset = 0;
+    const discriminator = data.readUInt8(offset);
+    offset += 1;
+    if (discriminator !== ACCOUNT_DISCRIMINATOR_METADATA) {
+        throw new Error(`Invalid metadata account discriminator: ${discriminator.toString()}`);
+    }
+    offset += 32; // program
+    offset += ZEROABLE_OPTION_PUBKEY_SIZE; // authority
+    offset += 1; // mutable
+    offset += 1; // canonical
+    offset += SEED_SIZE; // seed
+    const encoding = data.readUInt8(offset);
+    offset += 1;
+    const compression = data.readUInt8(offset);
+    offset += 1;
+    const format = data.readUInt8(offset);
+    if (format !== FORMAT_JSON) {
+        throw new Error(`IDL has data format '${format}', only JSON IDLs (${FORMAT_JSON}) are supported`);
+    }
+    offset += 1;
+    const dataSource = data.readUInt8(offset);
+    if (dataSource !== DATA_SOURCE_DIRECT) {
+        throw new Error(`IDL has source '${dataSource}', only directly embedded data (${DATA_SOURCE_DIRECT}) is supported`);
+    }
+    offset += 1;
+    const dataLength = data.readUInt32LE(offset);
+    offset += DATA_LENGTH_SIZE + DATA_LENGTH_PADDING;
+    if (data.length < offset + dataLength) {
+        throw new Error("Metadata account data is truncated");
+    }
+    const blob = data.subarray(offset, offset + dataLength);
+    const decoded = decodeMetadataData(uncompressMetadataData(blob, compression), encoding);
+    return JSON.parse(decoded);
+}
+function uncompressMetadataData(data, compression) {
+    switch (compression) {
+        case MetadataCompression.None:
+            return data;
+        case MetadataCompression.Gzip:
+            return Buffer$1.from(ungzip(data));
+        case MetadataCompression.Zlib:
+            return Buffer$1.from(inflate(data));
+        default:
+            throw new Error(`Unsupported metadata compression: ${String(compression)}`);
+    }
+}
+function decodeMetadataData(data, encoding) {
+    switch (encoding) {
+        // 'None' is actually hex-encoded
+        case MetadataEncoding.None:
+            return data.toString("hex");
+        case MetadataEncoding.Utf8:
+            return decode$2(data);
+        case MetadataEncoding.Base58:
+            return encode$1(data);
+        case MetadataEncoding.Base64:
+            return data.toString("base64");
+        default:
+            throw new Error(`Unsupported metadata encoding: ${String(encoding)}`);
+    }
 }
 /**
  * Convert the given IDL to camelCase.
@@ -1027,7 +1123,10 @@ class AnchorProvider {
         }
         else {
             tx.feePayer = (_a = tx.feePayer) !== null && _a !== void 0 ? _a : this.wallet.publicKey;
-            tx.recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
+            if (!tx.recentBlockhash ||
+                tx.recentBlockhash === "11111111111111111111111111111111") {
+                tx.recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
+            }
             if (signers) {
                 for (const signer of signers) {
                     tx.partialSign(signer);
@@ -4525,9 +4624,9 @@ var sha256 = /*#__PURE__*/Object.freeze({
 
 // Sync version of web3.PublicKey.createWithSeed.
 function createWithSeedSync(fromPublicKey, seed, programId) {
-    const buffer = Buffer$1.concat([
+    const buffer = Buffer.concat([
         fromPublicKey.toBuffer(),
-        Buffer$1.from(seed),
+        Buffer.from(seed),
         programId.toBuffer(),
     ]);
     return new PublicKey(sha256$1(buffer));
@@ -6693,7 +6792,7 @@ class NamespaceFactory {
  *
  * API specifics are namespace dependent. The examples used in the documentation
  * below will refer to the two counter examples found
- * [here](https://github.com/coral-xyz/anchor#examples).
+ * [here](https://github.com/solana-foundation/anchor#examples).
  */
 class Program {
     /**
@@ -6782,18 +6881,14 @@ class Program {
      * @param programId The on-chain address of the program.
      * @param provider  The network and wallet context.
      */
-    static async fetchIdl(address, provider) {
+    static async fetchIdl(programAddress, provider) {
         provider = provider !== null && provider !== void 0 ? provider : getProvider();
-        const programId = translateAddress(address);
-        const idlAddr = await idlAddress(programId);
+        const programId = translateAddress(programAddress);
+        const idlAddr = idlAddress(programId);
         const accountInfo = await provider.connection.getAccountInfo(idlAddr);
-        if (!accountInfo) {
+        if (!accountInfo)
             return null;
-        }
-        // Chop off account discriminator.
-        let idlAccount = decodeIdlAccount(accountInfo.data.slice(8));
-        const inflatedIdl = inflate(idlAccount.data);
-        return JSON.parse(decode$2(inflatedIdl));
+        return decodeIdlAccount(accountInfo.data);
     }
     /**
      * Invokes the given callback every time the given event is emitted.
@@ -7205,5 +7300,5 @@ class Native {
     }
 }
 
-export { AccountClient, AnchorError, AnchorProvider, BorshAccountsCoder, BorshCoder, BorshEventCoder, BorshInstructionCoder, EventManager, EventParser, IdlError, LangErrorCode, LangErrorMessage, MethodsBuilderFactory, Native, Program, ProgramError, ProgramErrorStack, SystemCoder, getProvider, parseIdlErrors, setProvider, splitArgsAndCtx, toInstruction, translateAddress, translateError, index as utils, validateAccounts };
+export { AccountClient, AnchorError, AnchorProvider, BorshAccountsCoder, BorshCoder, BorshEventCoder, BorshInstructionCoder, EventManager, EventParser, FORMAT_JSON, IdlError, LangErrorCode, LangErrorMessage, MetadataCompression, MetadataEncoding, MethodsBuilderFactory, Native, Program, ProgramError, ProgramErrorStack, SystemCoder, convertIdlToCamelCase, decodeIdlAccount, decodeMetadataData, getProvider, handleDefinedFields, idlAddress, isCompositeAccounts, parseIdlErrors, seed, setProvider, splitArgsAndCtx, toInstruction, translateAddress, translateError, uncompressMetadataData, index as utils, validateAccounts };
 //# sourceMappingURL=index.js.map