@layerzerolabs/lz-core 2.1.23

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @layerzerolabs/lz-core
+
+## 2.1.23
+
+### Patch Changes
+
+- c2fc9fe: - update dvn config on blast chain for some dvn partners
+  - update OApp, OFT contracts

package/README.md

@@ -0,0 +1 @@
+# layerzero-core

package/dist/index.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+// src/transaction.ts
+var Block = class _Block {
+  constructor(block) {
+    this.block = block;
+    this.type = "Block";
+  }
+  static from(raw) {
+    return new _Block(raw);
+  }
+};
+var BlockWithTransactions = class _BlockWithTransactions {
+  constructor(block) {
+    this.block = block;
+    this.type = "BlockWithTransactions";
+  }
+  static from(raw) {
+    return new _BlockWithTransactions(raw);
+  }
+};
+var TransactionRequest = class _TransactionRequest {
+  constructor(request) {
+    this.request = request;
+    this.type = "TransactionRequest";
+  }
+  static from(raw) {
+    return new _TransactionRequest(raw);
+  }
+};
+var TransactionResponse = class _TransactionResponse {
+  constructor(response) {
+    this.response = response;
+    this.type = "TransactionResponse";
+  }
+  static from(raw) {
+    return new _TransactionResponse(raw);
+  }
+};
+var TransactionReceipt = class _TransactionReceipt {
+  constructor(receipt) {
+    this.receipt = receipt;
+    this.type = "TransactionReceipt";
+  }
+  static from(raw) {
+    return new _TransactionReceipt(raw);
+  }
+};
+var SignedTransaction = class _SignedTransaction {
+  constructor(signed) {
+    this.signed = signed;
+    this.type = "SignedTransaction";
+  }
+  static from(raw) {
+    return new _SignedTransaction(raw);
+  }
+};
+var TransactionPending = class _TransactionPending {
+  constructor(pending) {
+    this.pending = pending;
+    this.type = "TransactionPending";
+  }
+  static from(raw) {
+    return new _TransactionPending(raw);
+  }
+};
+
+// src/signer.ts
+var Signer = class {
+};
+
+exports.Block = Block;
+exports.BlockWithTransactions = BlockWithTransactions;
+exports.SignedTransaction = SignedTransaction;
+exports.Signer = Signer;
+exports.TransactionPending = TransactionPending;
+exports.TransactionReceipt = TransactionReceipt;
+exports.TransactionRequest = TransactionRequest;
+exports.TransactionResponse = TransactionResponse;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transaction.ts","../src/signer.ts"],"names":[],"mappings":";AAmBO,IAAM,QAAN,MAAM,OAAM;AAAA,EAEP,YAAmB,OAAgB;AAAhB;AAD3B,SAAS,OAAO;AAAA,EAC4B;AAAA,EAC5C,OAAO,KAAQ,KAA2B;AACtC,WAAO,IAAI,OAAM,GAAG;AAAA,EACxB;AACJ;AAKO,IAAM,wBAAN,MAAM,uBAAsB;AAAA,EAEvB,YAAmB,OAAgB;AAAhB;AAD3B,SAAS,OAAO;AAAA,EAC4B;AAAA,EAC5C,OAAO,KAAQ,KAA2C;AACtD,WAAO,IAAI,uBAAsB,GAAG;AAAA,EACxC;AACJ;AAeO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;AAKO,IAAM,sBAAN,MAAM,qBAAoB;AAAA,EAErB,YAAmB,UAAmB;AAAnB;AAD3B,SAAS,OAAO;AAAA,EAC+B;AAAA,EAC/C,OAAO,KAAQ,KAAyC;AACpD,WAAO,IAAI,qBAAoB,GAAG;AAAA,EACtC;AACJ;AAKO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;AAKO,IAAM,oBAAN,MAAM,mBAAkB;AAAA,EAEnB,YAAmB,QAAiB;AAAjB;AAD3B,SAAS,OAAO;AAAA,EAC6B;AAAA,EAC7C,OAAO,KAAQ,KAAuC;AAClD,WAAO,IAAI,mBAAkB,GAAG;AAAA,EACpC;AACJ;AAKO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;;;AClGO,IAAe,SAAf,MAAsB;AAyC7B","sourcesContent":["import { NonPromise } from './promise'\n\n/**\n * By declare a unique field `type` in each class, it ensure that the instance of one class can not\n *  be assigned to a variable of another class. Furthermore, it also help to distinguish the type of\n * the instance at runtime.\n * By private the constructor, it ensure that the instance of the class can only be created by the\n * static method `from`, and which can enforce the type of the input parameter should not be a promise.\n * Finally, it will be helpful for the compiler to infer the type of the instance and avoid the mistake.\n */\n\n/**\n * TransactionHash represents a transaction hash.\n */\nexport type TransactionHash = string | number\n\n/**\n * Block represents a block.\n */\nexport class Block {\n    readonly type = 'Block'\n    private constructor(public block: unknown) {}\n    static from<T>(raw: NonPromise<T>): Block {\n        return new Block(raw)\n    }\n}\n\n/**\n * BlockWithTransactions represents a block with transactions.\n */\nexport class BlockWithTransactions {\n    readonly type = 'BlockWithTransactions'\n    private constructor(public block: unknown) {}\n    static from<T>(raw: NonPromise<T>): BlockWithTransactions {\n        return new BlockWithTransactions(raw)\n    }\n}\n\n/**\n * BlockTag represents a block tag.\n */\nexport type BlockTag = string | number\n\n/**\n * Finality represents the finality of a block.\n */\nexport type Finality = 'confirmed' | 'finalized'\n\n/**\n * TransactionRequest represents the request of a transaction.\n */\nexport class TransactionRequest {\n    readonly type = 'TransactionRequest'\n    private constructor(public request: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionRequest {\n        return new TransactionRequest(raw)\n    }\n}\n\n/**\n * TransactionResponse represents the response of a transaction.\n */\nexport class TransactionResponse {\n    readonly type = 'TransactionResponse'\n    private constructor(public response: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionResponse {\n        return new TransactionResponse(raw)\n    }\n}\n\n/**\n * TransactionReceipt represents the receipt of a transaction.\n */\nexport class TransactionReceipt {\n    readonly type = 'TransactionReceipt'\n    private constructor(public receipt: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionReceipt {\n        return new TransactionReceipt(raw)\n    }\n}\n\n/**\n * SignedTransaction represents a signed transaction.\n */\nexport class SignedTransaction {\n    readonly type = 'SignedTransaction'\n    private constructor(public signed: unknown) {}\n    static from<T>(raw: NonPromise<T>): SignedTransaction {\n        return new SignedTransaction(raw)\n    }\n}\n\n/**\n * TransactionPending represents a pending transaction.\n */\nexport class TransactionPending {\n    readonly type = 'TransactionPending'\n    private constructor(public pending: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionPending {\n        return new TransactionPending(raw)\n    }\n}\n","import { Provider } from './provider'\nimport { SignedTransaction, TransactionPending, TransactionReceipt, TransactionRequest } from './transaction'\n\nexport abstract class Signer {\n    /**\n     * Connect to a provider\n     * @param provider\n     */\n    abstract connect(provider: Provider): Signer\n\n    /**\n     * Sign a transaction\n     * @param transaction\n     */\n    abstract signTransaction(transaction: TransactionRequest): Promise<SignedTransaction>\n\n    /**\n     * Send a transaction\n     * @param transaction\n     * @param sendOptions\n     */\n    abstract sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>\n\n    /**\n     * Send a transaction and wait for confirmation\n     * @param transaction\n     * @param opts\n     */\n    abstract sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>\n\n    /**\n     * Sign a buffer (e.g. a message hash)\n     */\n    abstract signBuffer(buffer: Uint8Array): Promise<Uint8Array>\n\n    /**\n     * returns the address of the signer\n     */\n    abstract getAddress(): Promise<string>\n\n    /**\n     * Native signer object\n     */\n    native: unknown\n}\n"]}

package/dist/index.d.mts

@@ -0,0 +1,188 @@
+type NonPromise<T> = T extends Promise<unknown> ? never : T;
+
+/**
+ * By declare a unique field `type` in each class, it ensure that the instance of one class can not
+ *  be assigned to a variable of another class. Furthermore, it also help to distinguish the type of
+ * the instance at runtime.
+ * By private the constructor, it ensure that the instance of the class can only be created by the
+ * static method `from`, and which can enforce the type of the input parameter should not be a promise.
+ * Finally, it will be helpful for the compiler to infer the type of the instance and avoid the mistake.
+ */
+/**
+ * TransactionHash represents a transaction hash.
+ */
+type TransactionHash = string | number;
+/**
+ * Block represents a block.
+ */
+declare class Block {
+    block: unknown;
+    readonly type = "Block";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): Block;
+}
+/**
+ * BlockWithTransactions represents a block with transactions.
+ */
+declare class BlockWithTransactions {
+    block: unknown;
+    readonly type = "BlockWithTransactions";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): BlockWithTransactions;
+}
+/**
+ * BlockTag represents a block tag.
+ */
+type BlockTag = string | number;
+/**
+ * Finality represents the finality of a block.
+ */
+type Finality = 'confirmed' | 'finalized';
+/**
+ * TransactionRequest represents the request of a transaction.
+ */
+declare class TransactionRequest {
+    request: unknown;
+    readonly type = "TransactionRequest";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionRequest;
+}
+/**
+ * TransactionResponse represents the response of a transaction.
+ */
+declare class TransactionResponse {
+    response: unknown;
+    readonly type = "TransactionResponse";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionResponse;
+}
+/**
+ * TransactionReceipt represents the receipt of a transaction.
+ */
+declare class TransactionReceipt {
+    receipt: unknown;
+    readonly type = "TransactionReceipt";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionReceipt;
+}
+/**
+ * SignedTransaction represents a signed transaction.
+ */
+declare class SignedTransaction {
+    signed: unknown;
+    readonly type = "SignedTransaction";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): SignedTransaction;
+}
+/**
+ * TransactionPending represents a pending transaction.
+ */
+declare class TransactionPending {
+    pending: unknown;
+    readonly type = "TransactionPending";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionPending;
+}
+
+interface Provider {
+    /**
+     * Get the block specified by blockTag
+     * @param {BlockTag} [blockTag]
+     * @returns
+     */
+    getBlock(blockTag: BlockTag): Promise<Block>;
+    getBlockWithTransactions(blockTag: BlockTag): Promise<BlockWithTransactions>;
+    /**
+     * Get information about a transaction
+     * @param {string} txHash
+     * @returns
+     */
+    getTransaction(txHash: string): Promise<TransactionResponse>;
+    /**
+     * Get the receipt of a transaction
+     * @param txHash
+     */
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
+    /**
+     * Get the current block number
+     * @returns Promise<number> the current block number
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Get the current slot number for commitment
+     * @param commitment
+     */
+    getSlot(commitment?: Finality): Promise<number>;
+    /**
+     * Get the number of transactions sent from this address
+     * @param {string|Promise<string>} addressOrName The address to get the numbers of transactions from
+     * @param {BlockTag|Promise<BlockTag>} [blockTag] The block tag to get the numbers of transactions from
+     * @returns Promise<number> The number of transactions sent from this address
+     */
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    /**
+     * Get the balance of an address
+     * @param address
+     */
+    getBalance(address: string): Promise<string>;
+    /**
+     * Gets the UNIX timestamp for the block identified by blockTag.  The UNIX timestamp is defined as the count of
+     * seconds since the Unix Epoch on January 1st, 1970 at UTC.  If blockTag is not provided, the latest block is used.
+     * @param {string?} blockTag
+     * @returns Promise<number> the UNIX timestamp of the block identified by blockTag
+     */
+    getBlockTimestamp(blockTag: BlockTag): Promise<number>;
+    /**
+     * sendTransaction sends a signed transaction in bytes to the blockchain.
+     * @param transaction
+     * @param sendOptions
+     */
+    sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>;
+    /**
+     * Send a transaction and wait for confirmation
+     * @param transaction
+     * @param opts
+     */
+    sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>;
+    readonly native: unknown;
+    connectedTo<T>(item: T): T;
+}
+
+declare abstract class Signer {
+    /**
+     * Connect to a provider
+     * @param provider
+     */
+    abstract connect(provider: Provider): Signer;
+    /**
+     * Sign a transaction
+     * @param transaction
+     */
+    abstract signTransaction(transaction: TransactionRequest): Promise<SignedTransaction>;
+    /**
+     * Send a transaction
+     * @param transaction
+     * @param sendOptions
+     */
+    abstract sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>;
+    /**
+     * Send a transaction and wait for confirmation
+     * @param transaction
+     * @param opts
+     */
+    abstract sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>;
+    /**
+     * Sign a buffer (e.g. a message hash)
+     */
+    abstract signBuffer(buffer: Uint8Array): Promise<Uint8Array>;
+    /**
+     * returns the address of the signer
+     */
+    abstract getAddress(): Promise<string>;
+    /**
+     * Native signer object
+     */
+    native: unknown;
+}
+
+export { Block, type BlockTag, BlockWithTransactions, type Finality, type Provider, SignedTransaction, Signer, type TransactionHash, TransactionPending, TransactionReceipt, TransactionRequest, TransactionResponse };

package/dist/index.d.ts

@@ -0,0 +1,188 @@
+type NonPromise<T> = T extends Promise<unknown> ? never : T;
+
+/**
+ * By declare a unique field `type` in each class, it ensure that the instance of one class can not
+ *  be assigned to a variable of another class. Furthermore, it also help to distinguish the type of
+ * the instance at runtime.
+ * By private the constructor, it ensure that the instance of the class can only be created by the
+ * static method `from`, and which can enforce the type of the input parameter should not be a promise.
+ * Finally, it will be helpful for the compiler to infer the type of the instance and avoid the mistake.
+ */
+/**
+ * TransactionHash represents a transaction hash.
+ */
+type TransactionHash = string | number;
+/**
+ * Block represents a block.
+ */
+declare class Block {
+    block: unknown;
+    readonly type = "Block";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): Block;
+}
+/**
+ * BlockWithTransactions represents a block with transactions.
+ */
+declare class BlockWithTransactions {
+    block: unknown;
+    readonly type = "BlockWithTransactions";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): BlockWithTransactions;
+}
+/**
+ * BlockTag represents a block tag.
+ */
+type BlockTag = string | number;
+/**
+ * Finality represents the finality of a block.
+ */
+type Finality = 'confirmed' | 'finalized';
+/**
+ * TransactionRequest represents the request of a transaction.
+ */
+declare class TransactionRequest {
+    request: unknown;
+    readonly type = "TransactionRequest";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionRequest;
+}
+/**
+ * TransactionResponse represents the response of a transaction.
+ */
+declare class TransactionResponse {
+    response: unknown;
+    readonly type = "TransactionResponse";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionResponse;
+}
+/**
+ * TransactionReceipt represents the receipt of a transaction.
+ */
+declare class TransactionReceipt {
+    receipt: unknown;
+    readonly type = "TransactionReceipt";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionReceipt;
+}
+/**
+ * SignedTransaction represents a signed transaction.
+ */
+declare class SignedTransaction {
+    signed: unknown;
+    readonly type = "SignedTransaction";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): SignedTransaction;
+}
+/**
+ * TransactionPending represents a pending transaction.
+ */
+declare class TransactionPending {
+    pending: unknown;
+    readonly type = "TransactionPending";
+    private constructor();
+    static from<T>(raw: NonPromise<T>): TransactionPending;
+}
+
+interface Provider {
+    /**
+     * Get the block specified by blockTag
+     * @param {BlockTag} [blockTag]
+     * @returns
+     */
+    getBlock(blockTag: BlockTag): Promise<Block>;
+    getBlockWithTransactions(blockTag: BlockTag): Promise<BlockWithTransactions>;
+    /**
+     * Get information about a transaction
+     * @param {string} txHash
+     * @returns
+     */
+    getTransaction(txHash: string): Promise<TransactionResponse>;
+    /**
+     * Get the receipt of a transaction
+     * @param txHash
+     */
+    getTransactionReceipt(txHash: string): Promise<TransactionReceipt>;
+    /**
+     * Get the current block number
+     * @returns Promise<number> the current block number
+     */
+    getBlockNumber(): Promise<number>;
+    /**
+     * Get the current slot number for commitment
+     * @param commitment
+     */
+    getSlot(commitment?: Finality): Promise<number>;
+    /**
+     * Get the number of transactions sent from this address
+     * @param {string|Promise<string>} addressOrName The address to get the numbers of transactions from
+     * @param {BlockTag|Promise<BlockTag>} [blockTag] The block tag to get the numbers of transactions from
+     * @returns Promise<number> The number of transactions sent from this address
+     */
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    /**
+     * Get the balance of an address
+     * @param address
+     */
+    getBalance(address: string): Promise<string>;
+    /**
+     * Gets the UNIX timestamp for the block identified by blockTag.  The UNIX timestamp is defined as the count of
+     * seconds since the Unix Epoch on January 1st, 1970 at UTC.  If blockTag is not provided, the latest block is used.
+     * @param {string?} blockTag
+     * @returns Promise<number> the UNIX timestamp of the block identified by blockTag
+     */
+    getBlockTimestamp(blockTag: BlockTag): Promise<number>;
+    /**
+     * sendTransaction sends a signed transaction in bytes to the blockchain.
+     * @param transaction
+     * @param sendOptions
+     */
+    sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>;
+    /**
+     * Send a transaction and wait for confirmation
+     * @param transaction
+     * @param opts
+     */
+    sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>;
+    readonly native: unknown;
+    connectedTo<T>(item: T): T;
+}
+
+declare abstract class Signer {
+    /**
+     * Connect to a provider
+     * @param provider
+     */
+    abstract connect(provider: Provider): Signer;
+    /**
+     * Sign a transaction
+     * @param transaction
+     */
+    abstract signTransaction(transaction: TransactionRequest): Promise<SignedTransaction>;
+    /**
+     * Send a transaction
+     * @param transaction
+     * @param sendOptions
+     */
+    abstract sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>;
+    /**
+     * Send a transaction and wait for confirmation
+     * @param transaction
+     * @param opts
+     */
+    abstract sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>;
+    /**
+     * Sign a buffer (e.g. a message hash)
+     */
+    abstract signBuffer(buffer: Uint8Array): Promise<Uint8Array>;
+    /**
+     * returns the address of the signer
+     */
+    abstract getAddress(): Promise<string>;
+    /**
+     * Native signer object
+     */
+    native: unknown;
+}
+
+export { Block, type BlockTag, BlockWithTransactions, type Finality, type Provider, SignedTransaction, Signer, type TransactionHash, TransactionPending, TransactionReceipt, TransactionRequest, TransactionResponse };

package/dist/index.mjs

@@ -0,0 +1,72 @@
+// src/transaction.ts
+var Block = class _Block {
+  constructor(block) {
+    this.block = block;
+    this.type = "Block";
+  }
+  static from(raw) {
+    return new _Block(raw);
+  }
+};
+var BlockWithTransactions = class _BlockWithTransactions {
+  constructor(block) {
+    this.block = block;
+    this.type = "BlockWithTransactions";
+  }
+  static from(raw) {
+    return new _BlockWithTransactions(raw);
+  }
+};
+var TransactionRequest = class _TransactionRequest {
+  constructor(request) {
+    this.request = request;
+    this.type = "TransactionRequest";
+  }
+  static from(raw) {
+    return new _TransactionRequest(raw);
+  }
+};
+var TransactionResponse = class _TransactionResponse {
+  constructor(response) {
+    this.response = response;
+    this.type = "TransactionResponse";
+  }
+  static from(raw) {
+    return new _TransactionResponse(raw);
+  }
+};
+var TransactionReceipt = class _TransactionReceipt {
+  constructor(receipt) {
+    this.receipt = receipt;
+    this.type = "TransactionReceipt";
+  }
+  static from(raw) {
+    return new _TransactionReceipt(raw);
+  }
+};
+var SignedTransaction = class _SignedTransaction {
+  constructor(signed) {
+    this.signed = signed;
+    this.type = "SignedTransaction";
+  }
+  static from(raw) {
+    return new _SignedTransaction(raw);
+  }
+};
+var TransactionPending = class _TransactionPending {
+  constructor(pending) {
+    this.pending = pending;
+    this.type = "TransactionPending";
+  }
+  static from(raw) {
+    return new _TransactionPending(raw);
+  }
+};
+
+// src/signer.ts
+var Signer = class {
+};
+
+export { Block, BlockWithTransactions, SignedTransaction, Signer, TransactionPending, TransactionReceipt, TransactionRequest, TransactionResponse };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transaction.ts","../src/signer.ts"],"names":[],"mappings":";AAmBO,IAAM,QAAN,MAAM,OAAM;AAAA,EAEP,YAAmB,OAAgB;AAAhB;AAD3B,SAAS,OAAO;AAAA,EAC4B;AAAA,EAC5C,OAAO,KAAQ,KAA2B;AACtC,WAAO,IAAI,OAAM,GAAG;AAAA,EACxB;AACJ;AAKO,IAAM,wBAAN,MAAM,uBAAsB;AAAA,EAEvB,YAAmB,OAAgB;AAAhB;AAD3B,SAAS,OAAO;AAAA,EAC4B;AAAA,EAC5C,OAAO,KAAQ,KAA2C;AACtD,WAAO,IAAI,uBAAsB,GAAG;AAAA,EACxC;AACJ;AAeO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;AAKO,IAAM,sBAAN,MAAM,qBAAoB;AAAA,EAErB,YAAmB,UAAmB;AAAnB;AAD3B,SAAS,OAAO;AAAA,EAC+B;AAAA,EAC/C,OAAO,KAAQ,KAAyC;AACpD,WAAO,IAAI,qBAAoB,GAAG;AAAA,EACtC;AACJ;AAKO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;AAKO,IAAM,oBAAN,MAAM,mBAAkB;AAAA,EAEnB,YAAmB,QAAiB;AAAjB;AAD3B,SAAS,OAAO;AAAA,EAC6B;AAAA,EAC7C,OAAO,KAAQ,KAAuC;AAClD,WAAO,IAAI,mBAAkB,GAAG;AAAA,EACpC;AACJ;AAKO,IAAM,qBAAN,MAAM,oBAAmB;AAAA,EAEpB,YAAmB,SAAkB;AAAlB;AAD3B,SAAS,OAAO;AAAA,EAC8B;AAAA,EAC9C,OAAO,KAAQ,KAAwC;AACnD,WAAO,IAAI,oBAAmB,GAAG;AAAA,EACrC;AACJ;;;AClGO,IAAe,SAAf,MAAsB;AAyC7B","sourcesContent":["import { NonPromise } from './promise'\n\n/**\n * By declare a unique field `type` in each class, it ensure that the instance of one class can not\n *  be assigned to a variable of another class. Furthermore, it also help to distinguish the type of\n * the instance at runtime.\n * By private the constructor, it ensure that the instance of the class can only be created by the\n * static method `from`, and which can enforce the type of the input parameter should not be a promise.\n * Finally, it will be helpful for the compiler to infer the type of the instance and avoid the mistake.\n */\n\n/**\n * TransactionHash represents a transaction hash.\n */\nexport type TransactionHash = string | number\n\n/**\n * Block represents a block.\n */\nexport class Block {\n    readonly type = 'Block'\n    private constructor(public block: unknown) {}\n    static from<T>(raw: NonPromise<T>): Block {\n        return new Block(raw)\n    }\n}\n\n/**\n * BlockWithTransactions represents a block with transactions.\n */\nexport class BlockWithTransactions {\n    readonly type = 'BlockWithTransactions'\n    private constructor(public block: unknown) {}\n    static from<T>(raw: NonPromise<T>): BlockWithTransactions {\n        return new BlockWithTransactions(raw)\n    }\n}\n\n/**\n * BlockTag represents a block tag.\n */\nexport type BlockTag = string | number\n\n/**\n * Finality represents the finality of a block.\n */\nexport type Finality = 'confirmed' | 'finalized'\n\n/**\n * TransactionRequest represents the request of a transaction.\n */\nexport class TransactionRequest {\n    readonly type = 'TransactionRequest'\n    private constructor(public request: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionRequest {\n        return new TransactionRequest(raw)\n    }\n}\n\n/**\n * TransactionResponse represents the response of a transaction.\n */\nexport class TransactionResponse {\n    readonly type = 'TransactionResponse'\n    private constructor(public response: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionResponse {\n        return new TransactionResponse(raw)\n    }\n}\n\n/**\n * TransactionReceipt represents the receipt of a transaction.\n */\nexport class TransactionReceipt {\n    readonly type = 'TransactionReceipt'\n    private constructor(public receipt: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionReceipt {\n        return new TransactionReceipt(raw)\n    }\n}\n\n/**\n * SignedTransaction represents a signed transaction.\n */\nexport class SignedTransaction {\n    readonly type = 'SignedTransaction'\n    private constructor(public signed: unknown) {}\n    static from<T>(raw: NonPromise<T>): SignedTransaction {\n        return new SignedTransaction(raw)\n    }\n}\n\n/**\n * TransactionPending represents a pending transaction.\n */\nexport class TransactionPending {\n    readonly type = 'TransactionPending'\n    private constructor(public pending: unknown) {}\n    static from<T>(raw: NonPromise<T>): TransactionPending {\n        return new TransactionPending(raw)\n    }\n}\n","import { Provider } from './provider'\nimport { SignedTransaction, TransactionPending, TransactionReceipt, TransactionRequest } from './transaction'\n\nexport abstract class Signer {\n    /**\n     * Connect to a provider\n     * @param provider\n     */\n    abstract connect(provider: Provider): Signer\n\n    /**\n     * Sign a transaction\n     * @param transaction\n     */\n    abstract signTransaction(transaction: TransactionRequest): Promise<SignedTransaction>\n\n    /**\n     * Send a transaction\n     * @param transaction\n     * @param sendOptions\n     */\n    abstract sendTransaction(transaction: SignedTransaction, sendOptions?: any): Promise<TransactionPending>\n\n    /**\n     * Send a transaction and wait for confirmation\n     * @param transaction\n     * @param opts\n     */\n    abstract sendAndConfirm(transaction: SignedTransaction, opts?: any): Promise<TransactionReceipt>\n\n    /**\n     * Sign a buffer (e.g. a message hash)\n     */\n    abstract signBuffer(buffer: Uint8Array): Promise<Uint8Array>\n\n    /**\n     * returns the address of the signer\n     */\n    abstract getAddress(): Promise<string>\n\n    /**\n     * Native signer object\n     */\n    native: unknown\n}\n"]}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@layerzerolabs/lz-core",
+  "version": "2.1.23",
+  "description": "LayerZero Core Library",
+  "license": "BUSL-1.1",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "$npm_execpath clean-prebuild && $npm_execpath build-ts",
+    "build-ts": "$npm_execpath tsc --noEmit && $npm_execpath tsup",
+    "clean": "$npm_execpath clean-prebuild && rimraf .turbo",
+    "clean-prebuild": "rimraf dist"
+  },
+  "dependencies": {
+    "tiny-invariant": "^1.3.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@layerzerolabs/tsup-config-next": "^2.1.23",
+    "@layerzerolabs/typescript-config-next": "^2.1.23",
+    "@types/jest": "^29.5.10",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "tsup": "^8.0.1",
+    "typescript": "~5.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}