@bitgo-beta/sdk-coin-sol 7.6.4-beta.31 → 7.6.4-beta.310

package/dist/esm/bigint-buffer-guard.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=bigint-buffer-guard.d.ts.map

package/dist/esm/config/token2022StaticConfig.d.ts

@@ -0,0 +1,3 @@
+import type { Token2022Config } from '../lib/token2022Config';
+export declare const TOKEN_2022_STATIC_CONFIGS: Token2022Config[];
+//# sourceMappingURL=token2022StaticConfig.d.ts.map

package/dist/esm/config/token2022StaticConfig.js

@@ -0,0 +1,47 @@
+export const TOKEN_2022_STATIC_CONFIGS = [
+    {
+        mintAddress: '4MmJVdwYN8LwvbGeCowYjSx7KoEi6BJWg8XXnW4fDDp6',
+        transferHook: {
+            extraAccountMetas: [
+                {
+                    pubkey: '98wFF5MpMjMQbfDF2MPzo8LCGX37unZR1ohRA1mU9GmJ',
+                    isSigner: false,
+                    isWritable: true,
+                },
+                {
+                    pubkey: '48n7YGEww7fKMfJ5gJ3sQC3rM6RWGjpUsghqVfXVkR5A',
+                    isSigner: false,
+                    isWritable: false,
+                },
+                {
+                    pubkey: '9sQhAH7vV3RKTCK13VY4EiNjs3qBq1srSYxdNufdAAXm',
+                    isSigner: false,
+                    isWritable: false,
+                },
+            ],
+        },
+    },
+    {
+        mintAddress: '3BW95VLH2za2eUQ1PGfjxwMbpsnDFnmkA7m5LDgMKbX7',
+        transferHook: {
+            extraAccountMetas: [
+                {
+                    pubkey: 'GbQ8ZiEFzGGTeYoXwtZtcoxwPcMyUcmZDduMVNdUPKpX',
+                    isSigner: false,
+                    isWritable: true,
+                },
+                {
+                    pubkey: '2Te6MFDwstRP2sZi6DLbkhVcSfaQVffmpbudN6pmvAXo',
+                    isSigner: false,
+                    isWritable: false,
+                },
+                {
+                    pubkey: 'FR5YBEisx8mDe4ruhWKmpH5nirdJopj4uStBAVufqjMo',
+                    isSigner: false,
+                    isWritable: false,
+                },
+            ],
+        },
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+import './bigint-buffer-guard';
+export * from './lib';
+export * from './sol';
+export * from './solToken';
+export * from './tsol';
+export * from './register';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import './bigint-buffer-guard';
+export * from './lib';
+export * from './sol';
+export * from './solToken';
+export * from './tsol';
+export * from './register';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyx1QkFBdUIsQ0FBQztBQUMvQixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAnLi9iaWdpbnQtYnVmZmVyLWd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliJztcbmV4cG9ydCAqIGZyb20gJy4vc29sJztcbmV4cG9ydCAqIGZyb20gJy4vc29sVG9rZW4nO1xuZXhwb3J0ICogZnJvbSAnLi90c29sJztcbmV4cG9ydCAqIGZyb20gJy4vcmVnaXN0ZXInO1xuIl19

package/dist/esm/lib/ataInitializationBuilder.d.ts

@@ -0,0 +1,47 @@
+import { TransactionBuilder } from './transactionBuilder';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { TokenAssociateRecipient } from './iface';
+export declare class AtaInitializationBuilder extends TransactionBuilder {
+    private _tokenName;
+    private _mint;
+    private _owner;
+    private _tokenAssociateRecipients;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /** @inheritDoc */
+    initBuilder(tx: Transaction): void;
+    /**
+     * @deprecated - Use the enableToken method instead
+     * Sets the mint address of the associated token account
+     *
+     * @param tokenName name of the token
+     */
+    mint(tokenName: string): this;
+    /**
+     * @deprecated - Use the enableToken method instead
+     * Sets the owner address of the associated token account
+     *
+     * @param owner owner address of associated token account
+     */
+    owner(owner: string): this;
+    /**
+     * @deprecated - Use the associatedTokenAccountRent method instead
+     * Used to set the minimum rent exempt amount
+     *
+     * @param rentExemptAmount minimum rent exempt amount in lamports
+     */
+    rentExemptAmount(rentExemptAmount: string): this;
+    /**
+     * Used for adding token association recipients consisting
+     *  1. ownerAddress: owner of the token address
+     *  2. tokenName: the name of token enabled that is supported by BitGo
+     *
+     *  @param TokenAssociateRecipient token associate recipient info
+     */
+    enableToken(recipient: TokenAssociateRecipient): this;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=ataInitializationBuilder.d.ts.map

package/dist/esm/lib/ataInitializationBuilder.js

@@ -0,0 +1,156 @@
+import { TransactionBuilder } from './transactionBuilder';
+import { BuildTransactionError, DuplicateMethodError, TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { InstructionBuilderTypes } from './constants';
+import { getAssociatedTokenAccountAddress, getSolTokenFromTokenName, validateMintAddress, validateOwnerAddress, } from './utils';
+import assert from 'assert';
+import * as _ from 'lodash';
+export class AtaInitializationBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new Transaction(_coinConfig);
+        this._tokenAssociateRecipients = [];
+    }
+    get transactionType() {
+        return TransactionType.AssociatedTokenAccountInitialization;
+    }
+    /** @inheritDoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        this._tokenAssociateRecipients = [];
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount) {
+                const ataInitInstruction = instruction;
+                this._tokenAssociateRecipients.push({
+                    ownerAddress: ataInitInstruction.params.ownerAddress,
+                    tokenName: ataInitInstruction.params.tokenName,
+                    tokenAddress: ataInitInstruction.params.mintAddress,
+                    programId: ataInitInstruction.params.programId,
+                });
+            }
+        }
+    }
+    /**
+     * @deprecated - Use the enableToken method instead
+     * Sets the mint address of the associated token account
+     *
+     * @param tokenName name of the token
+     */
+    mint(tokenName) {
+        if (this._tokenAssociateRecipients.length > 0) {
+            throw new DuplicateMethodError('Invalid method: enableToken already used');
+        }
+        const token = getSolTokenFromTokenName(tokenName);
+        if (!token) {
+            throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + tokenName);
+        }
+        this._mint = token.tokenAddress;
+        this._tokenName = token.name;
+        validateMintAddress(this._mint);
+        return this;
+    }
+    /**
+     * @deprecated - Use the enableToken method instead
+     * Sets the owner address of the associated token account
+     *
+     * @param owner owner address of associated token account
+     */
+    owner(owner) {
+        if (this._tokenAssociateRecipients.length > 0) {
+            throw new DuplicateMethodError('Invalid method: enableToken already used');
+        }
+        this._owner = owner;
+        validateOwnerAddress(owner);
+        return this;
+    }
+    /**
+     * @deprecated - Use the associatedTokenAccountRent method instead
+     * Used to set the minimum rent exempt amount
+     *
+     * @param rentExemptAmount minimum rent exempt amount in lamports
+     */
+    rentExemptAmount(rentExemptAmount) {
+        return super.associatedTokenAccountRent(rentExemptAmount);
+    }
+    /**
+     * Used for adding token association recipients consisting
+     *  1. ownerAddress: owner of the token address
+     *  2. tokenName: the name of token enabled that is supported by BitGo
+     *
+     *  @param TokenAssociateRecipient token associate recipient info
+     */
+    enableToken(recipient) {
+        if (this._tokenAssociateRecipients.some((tokenAssociate) => _.isEqual(tokenAssociate, recipient))) {
+            throw new BuildTransactionError('Invalid transaction: invalid duplicate recipients, got: owner ' +
+                recipient.ownerAddress +
+                ' and tokenName ' +
+                recipient.tokenName +
+                ' twice');
+        }
+        if (this._tokenName || this._mint) {
+            throw new DuplicateMethodError('Invalid method: single mint already used');
+        }
+        validateOwnerAddress(recipient.ownerAddress);
+        const token = getSolTokenFromTokenName(recipient.tokenName);
+        let tokenAddress;
+        if (recipient.tokenAddress) {
+            tokenAddress = recipient.tokenAddress;
+        }
+        else if (token) {
+            tokenAddress = token.tokenAddress;
+        }
+        else {
+            throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);
+        }
+        validateMintAddress(tokenAddress);
+        this._tokenAssociateRecipients.push(recipient);
+        return this;
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._sender, 'Sender must be set before building the transaction');
+        if (this._tokenAssociateRecipients.length === 0) {
+            assert(this._mint && this._tokenName, 'Mint must be set before building the transaction');
+            this._owner = this._owner || this._sender;
+            this._tokenAssociateRecipients.push({
+                ownerAddress: this._owner,
+                tokenName: this._tokenName,
+            });
+        }
+        this._instructionsData = [];
+        await Promise.all(this._tokenAssociateRecipients.map(async (recipient) => {
+            const token = getSolTokenFromTokenName(recipient.tokenName);
+            let tokenAddress;
+            let programId;
+            if (recipient.tokenAddress && recipient.programId) {
+                tokenAddress = recipient.tokenAddress;
+                programId = recipient.programId;
+            }
+            else if (token) {
+                tokenAddress = token.tokenAddress;
+                programId = token.programId;
+            }
+            else {
+                throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);
+            }
+            // Use the provided ataAddress if it exists, otherwise calculate it
+            let ataPk = recipient.ataAddress;
+            if (!ataPk) {
+                ataPk = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress, false, programId);
+            }
+            this._instructionsData.push({
+                type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                params: {
+                    mintAddress: tokenAddress,
+                    ataAddress: ataPk,
+                    ownerAddress: recipient.ownerAddress,
+                    payerAddress: this._sender,
+                    tokenName: recipient.tokenName,
+                    programId: programId,
+                },
+            });
+        }));
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ataInitializationBuilder.js","sourceRoot":"","sources":["../../../src/lib/ataInitializationBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionBuilder } from './transactionBuilder';\nimport { BuildTransactionError, DuplicateMethodError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Transaction } from './transaction';\nimport { AtaInit, TokenAssociateRecipient } from './iface';\nimport { InstructionBuilderTypes } from './constants';\nimport {\n  getAssociatedTokenAccountAddress,\n  getSolTokenFromTokenName,\n  validateMintAddress,\n  validateOwnerAddress,\n} from './utils';\nimport assert from 'assert';\nimport * as _ from 'lodash';\n\nexport class AtaInitializationBuilder extends TransactionBuilder {\n  // @deprecated - Use the _tokenAssociateRecipients field instead\n  private _tokenName: string;\n  // @deprecated - Use the _tokenAssociateRecipients field instead\n  private _mint: string;\n  // @deprecated - Use the _tokenAssociateRecipients field instead\n  private _owner: string;\n  private _tokenAssociateRecipients: TokenAssociateRecipient[];\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n    this._tokenAssociateRecipients = [];\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.AssociatedTokenAccountInitialization;\n  }\n\n  /** @inheritDoc */\n  initBuilder(tx: Transaction): void {\n    super.initBuilder(tx);\n    this._tokenAssociateRecipients = [];\n    for (const instruction of this._instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount) {\n        const ataInitInstruction: AtaInit = instruction;\n        this._tokenAssociateRecipients.push({\n          ownerAddress: ataInitInstruction.params.ownerAddress,\n          tokenName: ataInitInstruction.params.tokenName,\n          tokenAddress: ataInitInstruction.params.mintAddress,\n          programId: ataInitInstruction.params.programId,\n        });\n      }\n    }\n  }\n\n  /**\n   * @deprecated - Use the enableToken method instead\n   * Sets the mint address of the associated token account\n   *\n   * @param tokenName name of the token\n   */\n  mint(tokenName: string): this {\n    if (this._tokenAssociateRecipients.length > 0) {\n      throw new DuplicateMethodError('Invalid method: enableToken already used');\n    }\n    const token = getSolTokenFromTokenName(tokenName);\n    if (!token) {\n      throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + tokenName);\n    }\n    this._mint = token.tokenAddress;\n    this._tokenName = token.name;\n    validateMintAddress(this._mint);\n    return this;\n  }\n\n  /**\n   * @deprecated - Use the enableToken method instead\n   * Sets the owner address of the associated token account\n   *\n   * @param owner owner address of associated token account\n   */\n  owner(owner: string): this {\n    if (this._tokenAssociateRecipients.length > 0) {\n      throw new DuplicateMethodError('Invalid method: enableToken already used');\n    }\n    this._owner = owner;\n    validateOwnerAddress(owner);\n    return this;\n  }\n\n  /**\n   * @deprecated - Use the associatedTokenAccountRent method instead\n   * Used to set the minimum rent exempt amount\n   *\n   * @param rentExemptAmount minimum rent exempt amount in lamports\n   */\n  rentExemptAmount(rentExemptAmount: string): this {\n    return super.associatedTokenAccountRent(rentExemptAmount);\n  }\n\n  /**\n   * Used for adding token association recipients consisting\n   *  1. ownerAddress: owner of the token address\n   *  2. tokenName: the name of token enabled that is supported by BitGo\n   *\n   *  @param TokenAssociateRecipient token associate recipient info\n   */\n\n  enableToken(recipient: TokenAssociateRecipient): this {\n    if (this._tokenAssociateRecipients.some((tokenAssociate) => _.isEqual(tokenAssociate, recipient))) {\n      throw new BuildTransactionError(\n        'Invalid transaction: invalid duplicate recipients, got: owner ' +\n          recipient.ownerAddress +\n          ' and tokenName ' +\n          recipient.tokenName +\n          ' twice'\n      );\n    }\n    if (this._tokenName || this._mint) {\n      throw new DuplicateMethodError('Invalid method: single mint already used');\n    }\n    validateOwnerAddress(recipient.ownerAddress);\n    const token = getSolTokenFromTokenName(recipient.tokenName);\n    let tokenAddress: string;\n    if (recipient.tokenAddress) {\n      tokenAddress = recipient.tokenAddress;\n    } else if (token) {\n      tokenAddress = token.tokenAddress;\n    } else {\n      throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);\n    }\n    validateMintAddress(tokenAddress);\n\n    this._tokenAssociateRecipients.push(recipient);\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected async buildImplementation(): Promise<Transaction> {\n    assert(this._sender, 'Sender must be set before building the transaction');\n    if (this._tokenAssociateRecipients.length === 0) {\n      assert(this._mint && this._tokenName, 'Mint must be set before building the transaction');\n      this._owner = this._owner || this._sender;\n\n      this._tokenAssociateRecipients.push({\n        ownerAddress: this._owner,\n        tokenName: this._tokenName,\n      });\n    }\n\n    this._instructionsData = [];\n    await Promise.all(\n      this._tokenAssociateRecipients.map(async (recipient) => {\n        const token = getSolTokenFromTokenName(recipient.tokenName);\n        let tokenAddress: string;\n        let programId: string;\n        if (recipient.tokenAddress && recipient.programId) {\n          tokenAddress = recipient.tokenAddress;\n          programId = recipient.programId;\n        } else if (token) {\n          tokenAddress = token.tokenAddress;\n          programId = token.programId;\n        } else {\n          throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);\n        }\n\n        // Use the provided ataAddress if it exists, otherwise calculate it\n        let ataPk = recipient.ataAddress;\n        if (!ataPk) {\n          ataPk = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress, false, programId);\n        }\n\n        this._instructionsData.push({\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            mintAddress: tokenAddress,\n            ataAddress: ataPk,\n            ownerAddress: recipient.ownerAddress,\n            payerAddress: this._sender,\n            tokenName: recipient.tokenName,\n            programId: programId,\n          },\n        });\n      })\n    );\n\n    return await super.buildImplementation();\n  }\n}\n"]}

package/dist/esm/lib/closeAtaBuilder.d.ts

@@ -0,0 +1,19 @@
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+export declare class CloseAtaBuilder extends TransactionBuilder {
+    protected _accountAddress: string;
+    protected _destinationAddress: string;
+    protected _authorityAddress: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    accountAddress(accountAddress: string): this;
+    destinationAddress(destinationAddress: string): this;
+    authorityAddress(authorityAddress: string): this;
+    /** @inheritDoc */
+    initBuilder(tx: Transaction): void;
+    /** @inheritdoc */
+    protected buildImplementation(): Promise<Transaction>;
+}
+//# sourceMappingURL=closeAtaBuilder.d.ts.map

package/dist/esm/lib/closeAtaBuilder.js

@@ -0,0 +1,62 @@
+import { BuildTransactionError, TransactionType } from '@bitgo-beta/sdk-core';
+import assert from 'assert';
+import { InstructionBuilderTypes } from './constants';
+import { Transaction } from './transaction';
+import { TransactionBuilder } from './transactionBuilder';
+import { validateAddress } from './utils';
+export class CloseAtaBuilder extends TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new Transaction(_coinConfig);
+    }
+    get transactionType() {
+        return TransactionType.CloseAssociatedTokenAccount;
+    }
+    accountAddress(accountAddress) {
+        validateAddress(accountAddress, 'accountAddress');
+        this._accountAddress = accountAddress;
+        return this;
+    }
+    destinationAddress(destinationAddress) {
+        validateAddress(destinationAddress, 'destinationAddress');
+        this._destinationAddress = destinationAddress;
+        return this;
+    }
+    authorityAddress(authorityAddress) {
+        validateAddress(authorityAddress, 'authorityAddress');
+        this._authorityAddress = authorityAddress;
+        return this;
+    }
+    /** @inheritDoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        for (const instruction of this._instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.CloseAssociatedTokenAccount) {
+                const ataCloseInstruction = instruction;
+                this.accountAddress(ataCloseInstruction.params.accountAddress);
+                this.destinationAddress(ataCloseInstruction.params.destinationAddress);
+                this.authorityAddress(ataCloseInstruction.params.authorityAddress);
+            }
+        }
+    }
+    /** @inheritdoc */
+    async buildImplementation() {
+        assert(this._accountAddress, 'Account Address must be set before building the transaction');
+        assert(this._destinationAddress, 'Destination Address must be set before building the transaction');
+        assert(this._authorityAddress, 'Authority Address must be set before building the transaction');
+        if (this._accountAddress === this._destinationAddress) {
+            throw new BuildTransactionError('Account address to close cannot be the same as the destination address');
+        }
+        const closeAssociatedTokenAccountData = {
+            type: InstructionBuilderTypes.CloseAssociatedTokenAccount,
+            params: {
+                accountAddress: this._accountAddress,
+                destinationAddress: this._destinationAddress,
+                authorityAddress: this._authorityAddress,
+            },
+        };
+        this._instructionsData = [closeAssociatedTokenAccountData];
+        return await super.buildImplementation();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/constants.d.ts

@@ -0,0 +1,164 @@
+import { ValidInstructionTypes } from './iface';
+export declare const MEMO_PROGRAM_PK = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+export declare const SEED_LENGTH = 32;
+export declare const MAX_MEMO_LENGTH = 130;
+export declare const STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT = 2282880;
+export declare const UNAVAILABLE_TEXT = "UNAVAILABLE";
+/**
+ * Maximum over-the-wire size of a Solana transaction (in bytes)
+ *
+ * Source: https://github.com/anza-xyz/agave/blob/v2.1.13/sdk/packet/src/lib.rs#L27-L29
+ *
+ * Calculation:
+ * - IPv6 minimum MTU: 1280 bytes
+ * - IPv6 header: 40 bytes
+ * - Fragment/UDP header: 8 bytes
+ * - Result: 1280 - 40 - 8 = 1232 bytes
+ *
+ * This limit is designed to avoid packet fragmentation on typical internet infrastructure.
+ * Transactions exceeding this limit will fail to serialize with a RangeError during
+ * the encoding of the transaction message.
+ *
+ * Reference: https://solana.com/docs/core/transactions#transaction-size
+ */
+export declare const SOLANA_TRANSACTION_MAX_SIZE = 1232;
+export declare const JITO_STAKE_POOL_ADDRESS = "Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb";
+export declare const JITOSOL_MINT_ADDRESS = "J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn";
+export declare const JITO_STAKE_POOL_RESERVE_ACCOUNT = "BgKUXdS29YcHCFrPm5M8oLHiTzZaMDjsebggjoaQ6KFL";
+export declare const JITO_STAKE_POOL_RESERVE_ACCOUNT_TESTNET = "rrWBQqRqBXYZw3CmPCCcjFxQ2Ds4JFJd7oRQJ997dhz";
+export declare const JITO_MANAGER_FEE_ACCOUNT = "feeeFLLsam6xZJFc6UQFrHqkvVt4jfmVvi2BRLkUZ4i";
+export declare const JITO_MANAGER_FEE_ACCOUNT_TESTNET = "DH7tmjoQ5zjqcgfYJU22JqmXhP5EY1tkbYpgVWUS2oNo";
+export declare enum ValidInstructionTypesEnum {
+    AdvanceNonceAccount = "AdvanceNonceAccount",
+    Create = "Create",
+    InitializeNonceAccount = "InitializeNonceAccount",
+    StakingInitialize = "Initialize",
+    StakingDelegate = "Delegate",
+    StakingDeactivate = "Deactivate",
+    StakingWithdraw = "Withdraw",
+    Transfer = "Transfer",
+    TokenTransfer = "TokenTransfer",
+    Memo = "Memo",
+    InitializeAssociatedTokenAccount = "InitializeAssociatedTokenAccount",
+    CloseAssociatedTokenAccount = "CloseAssociatedTokenAccount",
+    RecoverNestedAssociatedTokenAccount = "RecoverNestedAssociatedTokenAccount",
+    Allocate = "Allocate",
+    Assign = "Assign",
+    Split = "Split",
+    Authorize = "Authorize",
+    SetComputeUnitLimit = "SetComputeUnitLimit",
+    SetPriorityFee = "SetPriorityFee",
+    MintTo = "MintTo",
+    Burn = "Burn",
+    DepositSol = "DepositSol",
+    WithdrawStake = "WithdrawStake",
+    Approve = "Approve",
+    CustomInstruction = "CustomInstruction"
+}
+export declare enum InstructionBuilderTypes {
+    CreateNonceAccount = "CreateNonceAccount",
+    StakingActivate = "Activate",
+    StakingDeactivate = "Deactivate",
+    StakingWithdraw = "Withdraw",
+    Transfer = "Transfer",
+    Memo = "Memo",
+    NonceAdvance = "NonceAdvance",
+    CreateAssociatedTokenAccount = "CreateAssociatedTokenAccount",
+    CloseAssociatedTokenAccount = "CloseAssociatedTokenAccount",
+    RecoverNestedAssociatedTokenAccount = "RecoverNestedAssociatedTokenAccount",
+    TokenTransfer = "TokenTransfer",
+    StakingAuthorize = "Authorize",
+    StakingDelegate = "Delegate",
+    SetComputeUnitLimit = "SetComputeUnitLimit",
+    SetPriorityFee = "SetPriorityFee",
+    MintTo = "MintTo",
+    Burn = "Burn",
+    CustomInstruction = "CustomInstruction",
+    VersionedCustomInstruction = "VersionedCustomInstruction",
+    Approve = "Approve",
+    WithdrawStake = "WithdrawStake"
+}
+export declare const VALID_SYSTEM_INSTRUCTION_TYPES: ValidInstructionTypes[];
+/** Const to check the order of the Wallet Init instructions when decode */
+export declare const walletInitInstructionIndexes: {
+    readonly Create: 0;
+    readonly InitializeNonceAccount: 1;
+    readonly Memo: 2;
+};
+/** Const to check the order of the Staking Activate instructions when decode */
+export declare const stakingActivateInstructionsIndexes: {
+    readonly Create: 0;
+    readonly Initialize: 1;
+    readonly Delegate: 2;
+    readonly Memo: 3;
+};
+/** Const to check the order of the Marinade Staking Activate instructions when decode */
+export declare const marinadeStakingActivateInstructionsIndexes: {
+    readonly Create: 0;
+    readonly Initialize: 1;
+    readonly Memo: 2;
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export declare const jitoStakingActivateInstructionsIndexes: {
+    readonly DepositSol: 0;
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export declare const jitoStakingActivateWithATAInstructionsIndexes: {
+    readonly InitializeAssociatedTokenAccount: 0;
+    readonly DepositSol: 1;
+};
+/** Const to check the order of the Jito Staking Activate instructions when decode */
+export declare const jitoStakingDeactivateInstructionsIndexes: {
+    readonly Approve: 0;
+    readonly Create: 1;
+    readonly WithdrawStake: 2;
+};
+/** Const to check the order of the Staking Authorize instructions when decode */
+export declare const stakingAuthorizeInstructionsIndexes: {
+    readonly Authorize: 0;
+};
+/** Const to check the order of the Staking Delegate instructions when decode */
+export declare const stakingDelegateInstructionsIndexes: {
+    readonly Delegate: 0;
+};
+/** Const to check the order of the Staking Deactivate instructions when decode */
+export declare const stakingDeactivateInstructionsIndexes: {
+    readonly Deactivate: 0;
+    readonly Memo: 1;
+};
+/** Const to check the order of the Marinade Staking Deactivate instructions when decode */
+export declare const marinadeStakingDeactivateInstructionsIndexes: {
+    readonly Transfer: 0;
+    readonly Memo: 1;
+};
+/** Const to check the order of the Partial Staking Deactivate instructions when decoded */
+export declare const stakingPartialDeactivateInstructionsIndexes: {
+    readonly Transfer: 0;
+    readonly Allocate: 1;
+    readonly Assign: 2;
+    readonly Split: 3;
+    readonly Deactivate: 4;
+    readonly Memo: 5;
+};
+/** Const to check the order of the Staking Withdraw instructions when decode */
+export declare const stakingWithdrawInstructionsIndexes: {
+    readonly Withdraw: 0;
+    readonly Memo: 1;
+};
+/** Const to check the order of the ATA init instructions when decode */
+export declare const ataInitInstructionIndexes: {
+    readonly InitializeAssociatedTokenAccount: 0;
+    readonly Memo: 1;
+};
+/** Const to check the order of the ATA init instructions when decode */
+export declare const ataCloseInstructionIndexes: {
+    readonly CloseAssociatedTokenAccount: 0;
+};
+/** Const to check the order of the recover nested ATA instructions when decode */
+export declare const ataRecoverNestedInstructionIndexes: {
+    readonly RecoverNestedAssociatedTokenAccount: 0;
+};
+export declare const nonceAdvanceInstruction = "AdvanceNonceAccount";
+export declare const validInstructionData = "0a00000001000000";
+export declare const validInstructionData2 = "0a00000000000000";
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,eAAe,gDAAgD,CAAC;AAE7E,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,eAAO,MAAM,gCAAgC,UAAU,CAAC;AAExD,eAAO,MAAM,gBAAgB,gBAAgB,CAAC;AAE9C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAEhD,eAAO,MAAM,uBAAuB,gDAAgD,CAAC;AACrF,eAAO,MAAM,oBAAoB,iDAAiD,CAAC;AACnF,eAAO,MAAM,+BAA+B,iDAAiD,CAAC;AAC9F,eAAO,MAAM,uCAAuC,gDAAgD,CAAC;AACrG,eAAO,MAAM,wBAAwB,gDAAgD,CAAC;AACtF,eAAO,MAAM,gCAAgC,iDAAiD,CAAC;AAG/F,oBAAY,yBAAyB;IACnC,mBAAmB,wBAAwB;IAC3C,MAAM,WAAW;IACjB,sBAAsB,2BAA2B;IACjD,iBAAiB,eAAe;IAChC,eAAe,aAAa;IAC5B,iBAAiB,eAAe;IAChC,eAAe,aAAa;IAC5B,QAAQ,aAAa;IACrB,aAAa,kBAAkB;IAC/B,IAAI,SAAS;IACb,gCAAgC,qCAAqC;IACrE,2BAA2B,gCAAgC;IAC3D,mCAAmC,wCAAwC;IAC3E,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,mBAAmB,wBAAwB;IAC3C,cAAc,mBAAmB;IACjC,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,iBAAiB,sBAAsB;CACxC;AAGD,oBAAY,uBAAuB;IACjC,kBAAkB,uBAAuB;IACzC,eAAe,aAAa;IAC5B,iBAAiB,eAAe;IAChC,eAAe,aAAa;IAC5B,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,YAAY,iBAAiB;IAC7B,4BAA4B,iCAAiC;IAC7D,2BAA2B,gCAAgC;IAC3D,mCAAmC,wCAAwC;IAC3E,aAAa,kBAAkB;IAC/B,gBAAgB,cAAc;IAC9B,eAAe,aAAa;IAC5B,mBAAmB,wBAAwB;IAC3C,cAAc,mBAAmB;IACjC,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,iBAAiB,sBAAsB;IACvC,0BAA0B,+BAA+B;IACzD,OAAO,YAAY;IACnB,aAAa,kBAAkB;CAChC;AAED,eAAO,MAAM,8BAA8B,EAAE,qBAAqB,EA0BjE,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAC;AAEX,gFAAgF;AAChF,eAAO,MAAM,kCAAkC;;;;;CAKrC,CAAC;AAEX,yFAAyF;AACzF,eAAO,MAAM,0CAA0C;;;;CAI7C,CAAC;AAEX,qFAAqF;AACrF,eAAO,MAAM,sCAAsC;;CAEzC,CAAC;AAEX,qFAAqF;AACrF,eAAO,MAAM,6CAA6C;;;CAGhD,CAAC;AAEX,qFAAqF;AACrF,eAAO,MAAM,wCAAwC;;;;CAI3C,CAAC;AAEX,iFAAiF;AACjF,eAAO,MAAM,mCAAmC;;CAEtC,CAAC;AAEX,gFAAgF;AAChF,eAAO,MAAM,kCAAkC;;CAErC,CAAC;AAEX,kFAAkF;AAClF,eAAO,MAAM,oCAAoC;;;CAGvC,CAAC;AAEX,2FAA2F;AAC3F,eAAO,MAAM,4CAA4C;;;CAG/C,CAAC;AAEX,2FAA2F;AAC3F,eAAO,MAAM,2CAA2C;;;;;;;CAO9C,CAAC;AAEX,gFAAgF;AAChF,eAAO,MAAM,kCAAkC;;;CAGrC,CAAC;AAEX,wEAAwE;AACxE,eAAO,MAAM,yBAAyB;;;CAG5B,CAAC;AAEX,wEAAwE;AACxE,eAAO,MAAM,0BAA0B;;CAE7B,CAAC;AAEX,kFAAkF;AAClF,eAAO,MAAM,kCAAkC;;CAErC,CAAC;AAEX,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AACvD,eAAO,MAAM,qBAAqB,qBAAqB,CAAC"}