@1money/protocol-ts-sdk 1.0.15 → 1.1.0

package/es/api/tokens/types.d.ts

@@ -23,6 +23,7 @@ export interface MintInfo {
     black_list: AddressSchema[];
     white_list: AddressSchema[];
     metadata_update_authorities: AddressSchema[];
+    bridge_mint_authorities: AddressSchema[];
     supply: U256Schema;
     decimals: number;
     is_paused: boolean;
@@ -34,11 +35,12 @@ export interface KeyValuePair {
     value: string;
 }
 export declare enum AuthorityType {
-    MasterMint = "MasterMint",
+    MasterMint = "MasterMintBurn",
     MintBurnTokens = "MintBurnTokens",
     Pause = "Pause",
     ManageList = "ManageList",
-    UpdateMetadata = "UpdateMetadata"
+    UpdateMetadata = "UpdateMetadata",
+    Bridge = "Bridge"
 }
 export declare enum AuthorityAction {
     Grant = "Grant",
@@ -55,7 +57,6 @@ export declare enum PauseAction {
 export interface RestSignature extends Signature {
 }
 export interface TokenManageListPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     action: ManageListAction;
@@ -64,7 +65,6 @@ export interface TokenManageListPayload {
     signature: RestSignature;
 }
 export interface TokenBurnPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     recipient: string;
@@ -73,7 +73,6 @@ export interface TokenBurnPayload {
     signature: RestSignature;
 }
 export interface TokenAuthorityPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     action: AuthorityAction;
@@ -84,7 +83,6 @@ export interface TokenAuthorityPayload {
     signature: RestSignature;
 }
 export interface TokenIssuePayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     symbol: string;
@@ -95,7 +93,6 @@ export interface TokenIssuePayload {
     signature: RestSignature;
 }
 export interface TokenMintPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     recipient: string;
@@ -104,7 +101,6 @@ export interface TokenMintPayload {
     signature: RestSignature;
 }
 export interface TokenPausePayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     action: PauseAction;
@@ -112,7 +108,6 @@ export interface TokenPausePayload {
     signature: RestSignature;
 }
 export interface TokenMetadataPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     name: string;
@@ -121,3 +116,26 @@ export interface TokenMetadataPayload {
     additional_metadata: KeyValuePair[];
     signature: RestSignature;
 }
+export interface TokenBridgeAndMintPayload {
+    chain_id: number;
+    nonce: number;
+    recipient: string;
+    value: string;
+    token: string;
+    source_chain_id: number;
+    source_tx_hash: string;
+    bridge_metadata: string;
+    signature: RestSignature;
+}
+export interface TokenBurnAndBridgePayload {
+    bridge_metadata: string;
+    chain_id: number;
+    destination_address: string;
+    destination_chain_id: number;
+    escrow_fee: string;
+    nonce: number;
+    sender: string;
+    token: string;
+    value: string;
+    signature: RestSignature;
+}

package/es/api/transactions/index.d.ts

@@ -1,6 +1,5 @@
 import type { Hash } from '../../api/types';
-import type { Transaction } from '../../api/checkpoints/types';
-import type { TransactionReceipt, EstimateFee, PaymentPayload } from './types';
+import type { EstimateFee, PaymentPayload, Transaction, TransactionReceipt, FinalizedTransactionReceipt } from './types';
 /**
  * Transactions API methods
  */
@@ -17,6 +16,12 @@ export declare const transactionsApi: {
      * @returns Promise with transaction receipt response
      */
     getReceiptByHash: (hash: string) => import("../../client/index.js").PromiseWrapper<"custom", TransactionReceipt, TransactionReceipt, TransactionReceipt, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | TransactionReceipt, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<TransactionReceipt>;
+    /**
+     * Get finalized transaction by hash
+     * @param hash Hash of the transaction to lookup
+     * @returns Promise with finalized transaction receipt response
+     */
+    getFinalizedByHash: (hash: string) => import("../../client/index.js").PromiseWrapper<"custom", FinalizedTransactionReceipt, FinalizedTransactionReceipt, FinalizedTransactionReceipt, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | FinalizedTransactionReceipt, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<FinalizedTransactionReceipt>;
     /**
      * Estimate transaction fee
      * @param from Address of the transaction author

package/es/api/transactions/types.d.ts

@@ -1,5 +1,5 @@
+import { AuthorityType, RestSignature } from '../tokens/types';
 import { AddressSchema, B256Schema } from '../types';
-import { RestSignature } from '../tokens/types';
 export interface TransactionReceipt {
     success: boolean;
     transaction_hash: B256Schema;
@@ -10,11 +10,14 @@ export interface TransactionReceipt {
     to?: AddressSchema;
     token_address?: AddressSchema;
 }
+export interface FinalizedTransactionReceipt extends TransactionReceipt {
+    epoch: number;
+    counter_signatures: RestSignature[];
+}
 export interface EstimateFee {
     fee: string;
 }
 export interface PaymentPayload {
-    recent_checkpoint: number;
     chain_id: number;
     nonce: number;
     recipient: AddressSchema;
@@ -22,3 +25,147 @@ export interface PaymentPayload {
     token: AddressSchema;
     signature: RestSignature;
 }
+export interface TokenCreateData {
+    decimals: number;
+    is_private: boolean;
+    master_authority: AddressSchema;
+    name: string;
+    symbol: string;
+}
+export interface TokenTransferData {
+    recipient: AddressSchema;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenMintData {
+    recipient: AddressSchema;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenGrantAuthorityData {
+    authority_address: AddressSchema;
+    authority_type: AuthorityType;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenRevokeAuthorityData {
+    authority_address: AddressSchema;
+    authority_type: AuthorityType;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenBlacklistAccountData {
+    address: AddressSchema;
+    token: AddressSchema;
+}
+export interface TokenWhitelistAccountData {
+    address: AddressSchema;
+    token: AddressSchema;
+}
+export interface TokenBridgeAndMintData {
+    bridge_metadata: string | null;
+    recipient: AddressSchema;
+    source_chain_id: number;
+    source_tx_hash: string;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenBurnData {
+    recipient: AddressSchema;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenBurnAndBridgeData {
+    bridge_metadata: string | null;
+    destination_address: AddressSchema;
+    destination_chain_id: number;
+    escrow_fee: string;
+    sender: AddressSchema;
+    token: AddressSchema;
+    value: string;
+}
+export interface TokenCloseAccountData {
+    token: AddressSchema;
+}
+export interface TokenPauseData {
+    token: AddressSchema;
+}
+export interface TokenUpdateMetadataData {
+    metadata: {
+        name: string;
+        uri: string;
+        additional_metadata: Array<{
+            key: string;
+            value: string;
+        }>;
+    };
+    token: AddressSchema;
+}
+export interface RawData {
+    input: string;
+    token: AddressSchema;
+}
+export interface TokenUnpauseData {
+    token: AddressSchema;
+}
+interface BaseTransaction {
+    hash: B256Schema;
+    checkpoint_hash?: B256Schema;
+    checkpoint_number?: number;
+    transaction_index?: number;
+    chain_id: number;
+    from: AddressSchema;
+    nonce: number;
+    signature: {
+        r: string;
+        s: string;
+        v: number;
+    };
+}
+export type Transaction = (BaseTransaction & {
+    transaction_type: 'TokenCreate';
+    data: TokenCreateData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenTransfer';
+    data: TokenTransferData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenMint';
+    data: TokenMintData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenGrantAuthority';
+    data: TokenGrantAuthorityData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenRevokeAuthority';
+    data: TokenRevokeAuthorityData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenBlacklistAccount';
+    data: TokenBlacklistAccountData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenWhitelistAccount';
+    data: TokenWhitelistAccountData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenBridgeAndMint';
+    data: TokenBridgeAndMintData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenBurn';
+    data: TokenBurnData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenBurnAndBridge';
+    data: TokenBurnAndBridgeData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenCloseAccount';
+    data: TokenCloseAccountData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenPause';
+    data: TokenPauseData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenUnpause';
+    data: TokenUnpauseData;
+}) | (BaseTransaction & {
+    transaction_type: 'TokenUpdateMetadata';
+    data: TokenUpdateMetadataData;
+}) | (BaseTransaction & {
+    transaction_type: 'Raw';
+    data: RawData;
+});
+export {};

package/es/client/core.d.ts

@@ -1,4 +1,4 @@
-import type { AxiosStatic, AxiosRequestConfig, RawAxiosResponseHeaders, AxiosResponseHeaders, RawAxiosRequestHeaders, AxiosRequestHeaders } from 'axios';
+import type { AxiosRequestConfig, AxiosRequestHeaders, AxiosResponseHeaders, AxiosStatic, RawAxiosRequestHeaders, RawAxiosResponseHeaders } from 'axios';
 export type ParsedError<T extends string = string> = {
     name: T;
     message: string;

package/es/client/index.js

@@ -1,4 +1,4 @@
-import axios$1 from'axios';import'viem';import'@ethereumjs/rlp';function _typeof(ele) {
+import'viem';import'@ethereumjs/rlp';import axios$1 from'axios';function _typeof(ele) {
     if (typeof ele !== 'object')
         return (typeof ele).toLowerCase();
     const typeStr = Object.prototype.toString.call(ele);
@@ -261,9 +261,9 @@ class Request {
                 if (isTimeout)
                     return;
                 cleanup();
-                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})};`);
-                const status = err.response?.status ?? 500;
                 const data = err.response?.data ?? {};
+                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})}, Response: ${JSON.stringify(data)};`);
+                const status = err.response?.status ?? 500;
                 const headers = err.response?.headers ?? {};
                 try {
                     let res = data;

package/es/index.js

@@ -1,4 +1,4 @@
-import axios$1 from'axios';import {hexToBytes as hexToBytes$1,stringToBytes,keccak256,bytesToHex as bytesToHex$1,numberToHex,stringToHex,boolToHex}from'viem';import {encode}from'@ethereumjs/rlp';/**
+import {hexToBytes as hexToBytes$1,stringToBytes,keccak256,bytesToHex as bytesToHex$1,numberToHex,stringToHex,boolToHex}from'viem';import {encode}from'@ethereumjs/rlp';import axios$1 from'axios';/**
  * Derives the token account address given the wallet address and mint address.
  *
  * Address is 20 byte, 160 bits. Let's say if we want to support 50 billion
@@ -719,9 +719,10 @@ function encodePayload(payload) {
                     // hex-encoded data → raw bytes
                     return hexToBytes$1(v);
                 }
-                else if (!isNaN(+v)) {
+                else if (/^\d+$/.test(v)) {
                     // number-like string → hex → bytes
-                    return v === '0' ? new Uint8Array([]) : hexToBytes$1(numberToHex(+v));
+                    // Use BigInt for large numbers to avoid overflow
+                    return v === '0' ? new Uint8Array([]) : hexToBytes$1(numberToHex(BigInt(v)));
                 }
                 else {
                     // plain string → UTF-8 bytes
@@ -777,8 +778,16 @@ function toHex(value) {
             case 'bigint':
                 return numberToHex(value);
             case 'string':
-                if (!isNaN(+value))
-                    return numberToHex(+value);
+                // Only accept valid integer strings (no decimals, no whitespace, no empty)
+                if (/^-?\d+$/.test(value)) {
+                    // Use BigInt for potentially large numbers to avoid overflow
+                    try {
+                        return numberToHex(BigInt(value));
+                    }
+                    catch {
+                        return numberToHex(+value);
+                    }
+                }
                 return stringToHex(value);
             case 'uint8array':
             case 'uint16array':
@@ -1096,9 +1105,9 @@ class Request {
                 if (isTimeout)
                     return;
                 cleanup();
-                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})};`);
-                const status = err.response?.status ?? 500;
                 const data = err.response?.data ?? {};
+                console.error(`[1Money client]: Error(${err.status ?? 500}, ${err.code ?? 'UNKNOWN'}), Message: ${err.message}, Config: ${err.config?.method}, ${err.config?.baseURL ?? ''}${err.config?.url ?? ''}, ${JSON.stringify(err.config?.headers ?? {})}, Request: ${JSON.stringify(err.config?.data ?? {})}, Response: ${JSON.stringify(data)};`);
+                const status = err.response?.status ?? 500;
                 const headers = err.response?.headers ?? {};
                 try {
                     let res = data;
@@ -1223,6 +1232,14 @@ const accountsApi = {
     getNonce: (address) => {
         return get(`${API_PREFIX$4}/nonce?address=${address}`, { withCredentials: false });
     },
+    /**
+     * Get account bbnonce
+     * @param address Address of the account to lookup nonce for
+     * @returns Promise with bbnonce info response
+     */
+    getBbNonce: (address) => {
+        return get(`${API_PREFIX$4}/bbnonce?address=${address}`, { withCredentials: false });
+    },
     /**
      * Get associated token account
      * @param address Address of the account to lookup associated token account for
@@ -1261,6 +1278,14 @@ const checkpointsApi = {
      */
     getByNumber: (number, full = false) => {
         return get(`${API_PREFIX$3}/by_number?number=${number}&full=${full}`, { withCredentials: false });
+    },
+    /**
+     * Get checkpoint receipts by number
+     * @param number Number of the checkpoint to lookup
+     * @returns Promise with checkpoint receipts response
+     */
+    getReceiptsByNumber: (number) => {
+        return get(`${API_PREFIX$3}/receipts/by_number?number=${number}`, { withCredentials: false });
     }
 };const API_PREFIX$2 = `/${API_VERSION}/tokens`;
 /**
@@ -1338,6 +1363,22 @@ const tokensApi = {
      */
     updateMetadata: (payload) => {
         return post(`${API_PREFIX$2}/update_metadata`, payload, { withCredentials: false });
+    },
+    /**
+     * Bridge and mint tokens
+     * @param payload Token bridge and mint request payload
+     * @returns Promise with transaction hash response
+     */
+    bridgeAndMint: (payload) => {
+        return post(`${API_PREFIX$2}/bridge_and_mint`, payload, { withCredentials: false });
+    },
+    /**
+     * Burn and bridge tokens
+     * @param payload Token burn and bridge request payload
+     * @returns Promise with transaction hash response
+     */
+    burnAndBridge: (payload) => {
+        return post(`${API_PREFIX$2}/burn_and_bridge`, payload, { withCredentials: false });
     }
 };const API_PREFIX$1 = `/${API_VERSION}/transactions`;
 /**
@@ -1360,6 +1401,14 @@ const transactionsApi = {
     getReceiptByHash: (hash) => {
         return get(`${API_PREFIX$1}/receipt/by_hash?hash=${hash}`, { withCredentials: false });
     },
+    /**
+     * Get finalized transaction by hash
+     * @param hash Hash of the transaction to lookup
+     * @returns Promise with finalized transaction receipt response
+     */
+    getFinalizedByHash: (hash) => {
+        return get(`${API_PREFIX$1}/finalized/by_hash?hash=${hash}`, { withCredentials: false });
+    },
     /**
      * Estimate transaction fee
      * @param from Address of the transaction author
@@ -1397,11 +1446,12 @@ const chainApi = {
 };// Authority types
 var AuthorityType;
 (function (AuthorityType) {
-    AuthorityType["MasterMint"] = "MasterMint";
+    AuthorityType["MasterMint"] = "MasterMintBurn";
     AuthorityType["MintBurnTokens"] = "MintBurnTokens";
     AuthorityType["Pause"] = "Pause";
     AuthorityType["ManageList"] = "ManageList";
     AuthorityType["UpdateMetadata"] = "UpdateMetadata";
+    AuthorityType["Bridge"] = "Bridge";
 })(AuthorityType || (AuthorityType = {}));
 var AuthorityAction;
 (function (AuthorityAction) {

package/es/utils/index.js

@@ -719,9 +719,10 @@ function encodePayload(payload) {
                     // hex-encoded data → raw bytes
                     return hexToBytes$1(v);
                 }
-                else if (!isNaN(+v)) {
+                else if (/^\d+$/.test(v)) {
                     // number-like string → hex → bytes
-                    return v === '0' ? new Uint8Array([]) : hexToBytes$1(numberToHex(+v));
+                    // Use BigInt for large numbers to avoid overflow
+                    return v === '0' ? new Uint8Array([]) : hexToBytes$1(numberToHex(BigInt(v)));
                 }
                 else {
                     // plain string → UTF-8 bytes
@@ -777,8 +778,16 @@ function toHex(value) {
             case 'bigint':
                 return numberToHex(value);
             case 'string':
-                if (!isNaN(+value))
-                    return numberToHex(+value);
+                // Only accept valid integer strings (no decimals, no whitespace, no empty)
+                if (/^-?\d+$/.test(value)) {
+                    // Use BigInt for potentially large numbers to avoid overflow
+                    try {
+                        return numberToHex(BigInt(value));
+                    }
+                    catch {
+                        return numberToHex(+value);
+                    }
+                }
                 return stringToHex(value);
             case 'uint8array':
             case 'uint16array':

package/lib/__integration__/config.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Integration test configuration
+ *
+ * Environment variables:
+ * - INTEGRATION_TEST_NETWORK: Network to use (local, testnet, mainnet)
+ * - INTEGRATION_TEST_OPERATOR_KEY: Operator private key
+ * - INTEGRATION_TEST_MASTER_KEY: Master account private key
+ * - RUN_INTEGRATION_TESTS: Set to 'true' to run integration tests
+ */
+export interface IntegrationTestConfig {
+    network: 'local' | 'testnet' | 'mainnet';
+    operatorKey: string;
+    masterKey: string;
+    enabled: boolean;
+    timeout: number;
+}
+/**
+ * Get integration test configuration from environment variables
+ */
+export declare function getConfig(): IntegrationTestConfig;
+/**
+ * Check if integration tests should run
+ */
+export declare function shouldRunIntegrationTests(): boolean;

package/lib/__integration__/helpers.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Integration test helper utilities
+ */
+import type { RestSignature } from '../api/tokens/types';
+import type { TestAccount } from './setup';
+import type { Payload } from '../utils/interface';
+/**
+ * Create API client for integration tests
+ */
+export declare function createTestClient(): {
+    accounts: typeof import("../api/accounts").accountsApi;
+    checkpoints: typeof import("../api/checkpoints").checkpointsApi;
+    tokens: typeof import("../api/tokens").tokensApi;
+    transactions: typeof import("../api/transactions").transactionsApi;
+    chain: typeof import("../api/chain").chainApi;
+};
+/**
+ * Sign a payload with an account and return RestSignature format
+ */
+export declare function signPayload(payload: Payload, account: TestAccount): Promise<RestSignature>;
+/**
+ * Wait for a transaction to be finalized
+ * @param txHash Transaction hash
+ * @param maxRetries Maximum number of retries
+ * @param retryDelay Delay between retries in milliseconds
+ */
+export declare function waitForFinalization(txHash: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;
+/**
+ * Wait for a specific amount of time
+ */
+export declare function wait(ms: number): Promise<void>;
+/**
+ * Get current checkpoint number
+ */
+export declare function getCurrentCheckpoint(): Promise<number>;
+/**
+ * Get account nonce
+ */
+export declare function getAccountNonce(address: string): Promise<number>;
+/**
+ * Get chain ID
+ */
+export declare function getChainId(): Promise<number>;
+/**
+ * Derive token address from owner and nonce
+ */
+export declare function deriveTokenAddress(owner: string, nonce: number): string;
+/**
+ * Assert that a value is defined (throws if undefined/null)
+ */
+export declare function assertDefined<T>(value: T | undefined | null, message?: string): asserts value is T;
+/**
+ * Format test section header
+ */
+export declare function logSection(title: string): void;
+/**
+ * Format test step log
+ */
+export declare function logStep(step: string, detail?: string): void;
+/**
+ * Generate a random token symbol for testing
+ */
+export declare function generateRandomSymbol(prefix?: string): string;
+/**
+ * Normalize an address to checksum format for comparison
+ */
+export declare function normalizeAddress(address: string): string;
+/**
+ * Check if two addresses are equal (case-insensitive)
+ */
+export declare function addressEquals(addr1: string, addr2: string): boolean;
+/**
+ * Check if an array of addresses includes a specific address (case-insensitive)
+ */
+export declare function addressArrayIncludes(addresses: string[], targetAddress: string): boolean;

package/lib/__integration__/setup.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Integration test setup and account generation
+ */
+import type { PrivateKeyAccount } from 'viem/accounts';
+export interface TestAccount extends PrivateKeyAccount {
+    privateKey: `0x${string}`;
+}
+export interface TestAccounts {
+    operator: TestAccount;
+    master: TestAccount;
+    user1: TestAccount;
+    user2: TestAccount;
+    user3: TestAccount;
+}
+/**
+ * Generate and cache test accounts
+ */
+export declare function getTestAccounts(): TestAccounts;
+/**
+ * Log test account information
+ */
+export declare function logTestAccounts(): void;
+/**
+ * Reset test accounts (for cleanup)
+ */
+export declare function resetTestAccounts(): void;

package/lib/api/accounts/index.d.ts

@@ -1,4 +1,4 @@
-import type { AccountInfo, AssociatedTokenAccount } from './types';
+import type { AccountInfo, AssociatedTokenAccount, BbNonceInfo } from './types';
 /**
  * Accounts API methods
  */
@@ -9,6 +9,12 @@ export declare const accountsApi: {
      * @returns Promise with account info response
      */
     getNonce: (address: string) => import("../../client/index.js").PromiseWrapper<"custom", AccountInfo, AccountInfo, AccountInfo, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | AccountInfo, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<AccountInfo>;
+    /**
+     * Get account bbnonce
+     * @param address Address of the account to lookup nonce for
+     * @returns Promise with bbnonce info response
+     */
+    getBbNonce: (address: string) => import("../../client/index.js").PromiseWrapper<"custom", BbNonceInfo, BbNonceInfo, BbNonceInfo, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | BbNonceInfo, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<BbNonceInfo>;
     /**
      * Get associated token account
      * @param address Address of the account to lookup associated token account for

package/lib/api/accounts/types.d.ts

@@ -1,9 +1,11 @@
-import { AddressSchema, U256Schema } from '../types';
+import { U256Schema } from '../types';
 export interface AccountInfo {
     nonce: number;
 }
+export interface BbNonceInfo {
+    bbnonce: number;
+}
 export interface AssociatedTokenAccount {
-    token_account_address: AddressSchema;
     balance: U256Schema;
     nonce: number;
 }

package/lib/api/checkpoints/index.d.ts

@@ -1,4 +1,4 @@
-import type { CheckpointNumberResponse, Checkpoint } from './types';
+import type { Checkpoint, CheckpointNumberResponse, CheckpointReceipts } from './types';
 /**
  * Checkpoint API methods
  */
@@ -22,5 +22,11 @@ export declare const checkpointsApi: {
      * @returns Promise with checkpoint response
      */
     getByNumber: (number: number | string, full?: boolean) => import("../../client/index.js").PromiseWrapper<"custom", Checkpoint, Checkpoint, Checkpoint, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | Checkpoint, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<Checkpoint>;
+    /**
+     * Get checkpoint receipts by number
+     * @param number Number of the checkpoint to lookup
+     * @returns Promise with checkpoint receipts response
+     */
+    getReceiptsByNumber: (number: number | string) => import("../../client/index.js").PromiseWrapper<"custom", CheckpointReceipts, CheckpointReceipts, CheckpointReceipts, import("../../client/index.js").ParsedError<string>, import("../../client/index.js").ParsedError<string> | CheckpointReceipts, import("../../client/index.js").ParsedError<"timeout">, ""> & Promise<CheckpointReceipts>;
 };
 export default checkpointsApi;