├── .gitignore
├── .prettierrc
├── typedoc.json
├── rollup.config.ts
├── tsconfig.json
├── package.json
├── .github
    └── workflows
    │   └── master.yaml
├── .eslintrc
├── typedoc.css
├── README.md
├── src
    ├── adapters.ts
    ├── utils.ts
    ├── models.ts
    ├── stream.ts
    ├── index.ts
    └── contract.ts
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | node_modules/
3 | dist/
4 | vanilla/
5 | docs/
6 | package-lock.json
7 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | tabWidth: 2
2 | printWidth: 120
3 | useTabs: false
4 | semi: true
5 | singleQuote: true
6 | trailingComma: "all"
7 | bracketSpacing: true
8 | arrowParens: "avoid"
9 | 


--------------------------------------------------------------------------------
/typedoc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "entryPoints": [
 3 |     "src/index.ts"
 4 |   ],
 5 |   "out": "docs",
 6 |   "readme": "none",
 7 |   "excludePrivate": true,
 8 |   "includeVersion": true,
 9 |   "categorizeByGroup": false,
10 |   "categoryOrder": [
11 |     "Provider",
12 |     "Contract",
13 |     "Stream",
14 |     "Models",
15 |     "Provider Api",
16 |     "Utils",
17 |     "*"
18 |   ],
19 |   "sort": [
20 |     "source-order"
21 |   ],
22 |   "hideGenerator": true,
23 |   "customCss": "typedoc.css"
24 | }
25 | 


--------------------------------------------------------------------------------
/rollup.config.ts:
--------------------------------------------------------------------------------
 1 | import typescript from '@rollup/plugin-typescript';
 2 | import terser from '@rollup/plugin-terser';
 3 | import path from 'path';
 4 | 
 5 | const outDir = 'vanilla';
 6 | const libName = 'everscale';
 7 | 
 8 | export default {
 9 |   input: 'src/index.ts',
10 |   output: [
11 |     {
12 |       format: 'iife',
13 |       name: libName,
14 |       file: path.join(outDir, 'everscale.js'),
15 |     },
16 |     {
17 |       format: 'iife',
18 |       name: libName,
19 |       file: path.join(outDir, 'everscale.min.js'),
20 |       plugins: [terser()],
21 |     },
22 |   ],
23 |   plugins: [
24 |     typescript({
25 |       compilerOptions: {
26 |         module: 'esnext',
27 |       },
28 |       outDir,
29 |     }),
30 |   ],
31 | };
32 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es2018",
 4 |     "module": "commonjs",
 5 |     "outDir": "./dist",
 6 |     "strict": true,
 7 |     "noUnusedParameters": true,
 8 |     "noImplicitReturns": true,
 9 |     "noFallthroughCasesInSwitch": true,
10 |     "moduleResolution": "node",
11 |     "typeRoots": [
12 |       "node_modules/@types",
13 |       "node_modules/web-ext-types"
14 |     ],
15 |     "allowSyntheticDefaultImports": true,
16 |     "esModuleInterop": true,
17 |     "skipLibCheck": true,
18 |     "forceConsistentCasingInFileNames": true,
19 |     "declaration": true,
20 |     "downlevelIteration": true,
21 |     "lib": [
22 |       "dom",
23 |       "es5",
24 |       "es6",
25 |       "es2017.object",
26 |       "es2018",
27 |       "scripthost",
28 |       "ESNext"
29 |     ],
30 |   },
31 |   "include": [
32 |     "src/**/*"
33 |   ]
34 | }
35 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "everscale-inpage-provider",
 3 |   "version": "0.6.3",
 4 |   "description": "Web3-like interface to the Everscale blockchain",
 5 |   "repository": "https://github.com/broxus/everscale-inpage-provider",
 6 |   "main": "dist/index.js",
 7 |   "types": "dist/index.d.ts",
 8 |   "scripts": {
 9 |     "build": "tsc",
10 |     "build:vanilla": "rollup --config rollup.config.ts --configPlugin typescript",
11 |     "build:docs": "typedoc",
12 |     "lint": "npx eslint ."
13 |   },
14 |   "author": "",
15 |   "license": "GPL-3.0",
16 |   "devDependencies": {
17 |     "@rollup/plugin-terser": "^0.2.1",
18 |     "@rollup/plugin-typescript": "^10.0.1",
19 |     "@typescript-eslint/eslint-plugin": "^5.31.0",
20 |     "@typescript-eslint/parser": "^5.31.0",
21 |     "eslint": "^8.21.0",
22 |     "eslint-config-prettier": "^8.5.0",
23 |     "eslint-plugin-prettier": "^4.2.1",
24 |     "rollup": "^3.9.0",
25 |     "typedoc": "^0.23.10",
26 |     "typedoc-plugin-missing-exports": "^0.23.0",
27 |     "typescript": "^4.2.4"
28 |   },
29 |   "files": [
30 |     "/dist"
31 |   ]
32 | }
33 | 


--------------------------------------------------------------------------------
/.github/workflows/master.yaml:
--------------------------------------------------------------------------------
 1 | on:
 2 |   push:
 3 |     branches:
 4 |       - master
 5 | 
 6 | name: master
 7 | 
 8 | jobs:
 9 |   docs:
10 |     name: Generate docs
11 |     runs-on: ubuntu-latest
12 |     steps:
13 |       - name: Checkout sources
14 |         uses: actions/checkout@v4
15 | 
16 |       - name: Use Node.js 22
17 |         uses: actions/setup-node@v4
18 |         with:
19 |           node-version: 22
20 | 
21 |       - name: Install dependencies
22 |         run: npm install
23 | 
24 |       - name: Generate documentation
25 |         run: npm run build:docs
26 | 
27 |       - name: Deploy
28 |         uses: peaceiris/actions-gh-pages@v4
29 |         with:
30 |           github_token: ${{ secrets.GITHUB_TOKEN }}
31 |           publish_dir: ./docs
32 | 
33 |   vanilla:
34 |     name: Build minified dist
35 |     runs-on: ubuntu-latest
36 |     steps:
37 |       - name: Checkout sources
38 |         uses: actions/checkout@v4
39 | 
40 |       - name: Use Node.js 22
41 |         uses: actions/setup-node@v4
42 |         with:
43 |           node-version: 22
44 | 
45 |       - name: Install dependencies
46 |         run: npm install
47 | 
48 |       - name: Build
49 |         run: npm run build:vanilla
50 | 
51 |       - name: Upload artifacts
52 |         uses: actions/upload-artifact@v4
53 |         with:
54 |           name: vanilla-dist
55 |           path: |
56 |             vanilla
57 |             !vanilla/**/*.d.ts
58 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "env": {
 3 |     "browser": true,
 4 |     "node": true,
 5 |     "webextensions": true,
 6 |     "worker": true,
 7 |     "serviceworker": true
 8 |   },
 9 |   "extends": [
10 |     "eslint:recommended",
11 |     "plugin:@typescript-eslint/recommended",
12 |     "prettier"
13 |   ],
14 |   "parser": "@typescript-eslint/parser",
15 |   "parserOptions": {
16 |     "sourceType": "module"
17 |   },
18 |   "plugins": [
19 |     "@typescript-eslint",
20 |     "prettier"
21 |   ],
22 |   "ignorePatterns": [
23 |     "dist/*",
24 |     "docs/*"
25 |   ],
26 |   "rules": {
27 |     "no-constant-condition": "off",
28 |     "no-var": "error",
29 |     "semi": "error",
30 |     "no-multi-spaces": "error",
31 |     "space-in-parens": "error",
32 |     "no-multiple-empty-lines": "error",
33 |     "prefer-const": [
34 |       "error",
35 |       {
36 |         "destructuring": "all",
37 |         "ignoreReadBeforeAssign": false
38 |       }
39 |     ],
40 |     "camelcase": "error",
41 |     "linebreak-style": [
42 |       "error",
43 |       "unix"
44 |     ],
45 |     "quotes": [
46 |       "error",
47 |       "single"
48 |     ],
49 |     "no-unused-vars": "off",
50 |     "@typescript-eslint/no-unused-vars": [
51 |       "error",
52 |       {
53 |         "argsIgnorePattern": "^_",
54 |         "varsIgnorePattern": "^_",
55 |         "caughtErrorsIgnorePattern": "^_"
56 |       }
57 |     ],
58 |     "@typescript-eslint/ban-ts-comment": "off",
59 |     "@typescript-eslint/no-use-before-define": "off",
60 |     "@typescript-eslint/no-explicit-any": "off",
61 |     "@typescript-eslint/no-non-null-assertion": "off",
62 |     "@typescript-eslint/ban-types": [
63 |       "error",
64 |       {
65 |         "types": {
66 |           "{}": false
67 |         }
68 |       }
69 |     ],
70 |     "@typescript-eslint/no-this-alias": [
71 |       "error",
72 |       {
73 |         "allowedNames": [
74 |           "self"
75 |         ]
76 |       }
77 |     ]
78 |   }
79 | }
80 | 


--------------------------------------------------------------------------------
/typedoc.css:
--------------------------------------------------------------------------------
 1 | @font-face {
 2 |     font-family: 'JetBrains Mono';
 3 |     src: url('https://cdn.jsdelivr.net/gh/JetBrains/JetBrainsMono/web/woff2/JetBrainsMono-Regular.woff2') format('woff2'),
 4 |     url('https://cdn.jsdelivr.net/gh/JetBrains/JetBrainsMono/web/woff/JetBrainsMono-Regular.woff') format('woff'),
 5 |     url('https://cdn.jsdelivr.net/gh/JetBrains/JetBrainsMono/ttf/JetBrainsMono-Regular.ttf') format('truetype');
 6 |     font-weight: 400;
 7 |     font-style: normal;
 8 | }
 9 | 
10 | * {
11 |     font-family: 'JetBrains Mono', 'Fira Code', monospace;
12 | }
13 | 
14 | :root {
15 |     --light-color-input-background: var(--light-color-accent);
16 | 
17 |     --dark-color-background: #282828;
18 |     --dark-color-background-secondary: #1d2021;
19 |     --dark-color-icon-background: var(--dark-color-background-secondary);
20 |     --dark-color-input-background: #a89984;
21 |     --dark-color-accent: #fbf1c7;
22 |     --dark-color-text: #ebdbb2;
23 |     --dark-color-text-aside: #d5c4a1;
24 |     --dark-color-link: #83a598;
25 | }
26 | 
27 | 
28 | @media (prefers-color-scheme: light) {
29 |     :root {
30 |         --color-input-background: var(--light-color-input-background);
31 |     }
32 | }
33 | 
34 | @media (prefers-color-scheme: dark) {
35 |     :root {
36 |         --color-input-background: var(--dark-color-input-background);
37 |     }
38 | }
39 | 
40 | :root[data-theme="light"] {
41 |     --color-input-background: var(--light-color-input-background);
42 | }
43 | 
44 | :root[data-theme="dark"] {
45 |     --color-input-background: var(--dark-color-input-background);
46 | }
47 | 
48 | :root[data-theme="dark"] .tsd-checkbox-background {
49 |     fill: var(--color-input-background);
50 | }
51 | 
52 | :root[data-theme="dark"] #tsd-search.has-focus {
53 |     background-color: var(--color-input-background);
54 | }
55 | 
56 | :root[data-theme="dark"] #tsd-search .field input {
57 |     color: var(--color-background);
58 | }
59 | 
60 | :root[data-theme="dark"] #tsd-search .results li:hover a {
61 |     color: var(--color-background);
62 | }
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <p align="center">
  2 |   <a href="https://github.com/venom-blockchain/developer-program">
  3 |     <img src="https://raw.githubusercontent.com/venom-blockchain/developer-program/main/vf-dev-program.png" alt="Logo" width="366.8" height="146.4">
  4 |   </a>
  5 | </p>
  6 | 
  7 | # Everscale inpage provider &emsp;  [![Latest Version]][npmjs.com] [![Docs badge]][docs]
  8 | 
  9 | ## About
 10 | 
 11 | Web3-like interface to the Everscale blockchain.
 12 | 
 13 | ## Usage
 14 | 
 15 | ### How to install
 16 | 
 17 | ```shell
 18 | npm install --save everscale-inpage-provider
 19 | ```
 20 | 
 21 | > NOTE: this repo was originally used for `ton-inpage-provider` package which is DEPRECATED now.
 22 | 
 23 | ### Contents
 24 | 
 25 | - [`src/api.ts`](./src/api.ts) - RPC interface description
 26 | - [`src/models.ts`](./src/models.ts) - general models, used in RPC interface
 27 | - [`src/contract.ts`](./src/contract.ts) - typed contracts wrapper
 28 | - [`src/stream.ts`](./src/stream.ts) - user-friendly api for streams
 29 | - [`src/utils.ts`](./src/utils.ts) - some useful stuff
 30 | 
 31 | ### Example
 32 | 
 33 | ```typescript
 34 | import {
 35 |   Address,
 36 |   ProviderRpcClient,
 37 |   TvmException
 38 | } from 'everscale-inpage-provider';
 39 | 
 40 | const ever = new ProviderRpcClient();
 41 | 
 42 | async function myApp() {
 43 |   if (!(await ever.hasProvider())) {
 44 |     throw new Error('Extension is not installed');
 45 |   }
 46 | 
 47 |   const { accountInteraction } = await ever.requestPermissions({
 48 |     permissions: ['basic', 'accountInteraction'],
 49 |   });
 50 |   if (accountInteraction == null) {
 51 |     throw new Error('Insufficient permissions');
 52 |   }
 53 | 
 54 |   const selectedAddress = accountInteraction.address;
 55 |   const dePoolAddress = new Address('0:bbcbf7eb4b6f1203ba2d4ff5375de30a5408a8130bf79f870efbcfd49ec164e9');
 56 | 
 57 |   const dePool = new ever.Contract(DePoolAbi, dePoolAddress);
 58 | 
 59 |   const transaction = await dePool
 60 |     .methods
 61 |     .addOrdinaryStake({
 62 |       stake: '10000000000',
 63 |     }).send({
 64 |       from: selectedAddress,
 65 |       amount: '10500000000',
 66 |       bounce: true,
 67 |     });
 68 |   console.log(transaction);
 69 | 
 70 |   try {
 71 |     const output = await dePool
 72 |       .methods
 73 |       .getParticipantInfo({
 74 |         addr: selectedAddress,
 75 |       })
 76 |       .call();
 77 |     console.log(output);
 78 |   } catch (e) {
 79 |     if (e instanceof TvmException) {
 80 |       console.error(e.code);
 81 |     }
 82 |   }
 83 | }
 84 | 
 85 | const DePoolAbi = {
 86 |   'ABI version': 2,
 87 |   'header': ['time', 'expire'],
 88 |   'functions': [{
 89 |     'name': 'addOrdinaryStake',
 90 |     'inputs': [
 91 |       { 'name': 'stake', 'type': 'uint64' },
 92 |     ],
 93 |     'outputs': [],
 94 |   }, {
 95 |     'name': 'getParticipantInfo',
 96 |     'inputs': [
 97 |       { 'name': 'addr', 'type': 'address' },
 98 |     ],
 99 |     'outputs': [
100 |       { 'name': 'total', 'type': 'uint64' },
101 |       { 'name': 'withdrawValue', 'type': 'uint64' },
102 |       { 'name': 'reinvest', 'type': 'bool' },
103 |       { 'name': 'reward', 'type': 'uint64' },
104 |       { 'name': 'stakes', 'type': 'map(uint64,uint64)' },
105 |       {
106 |         'components': [
107 |           { 'name': 'remainingAmount', 'type': 'uint64' },
108 |           { 'name': 'lastWithdrawalTime', 'type': 'uint64' },
109 |           { 'name': 'withdrawalPeriod', 'type': 'uint32' },
110 |           { 'name': 'withdrawalValue', 'type': 'uint64' },
111 |           { 'name': 'owner', 'type': 'address',
112 |         }],
113 |         'name': 'vestings', 'type': 'map(uint64,tuple)',
114 |       },
115 |       {
116 |         'components': [
117 |           { 'name': 'remainingAmount', 'type': 'uint64' },
118 |           { 'name': 'lastWithdrawalTime', 'type': 'uint64' },
119 |           { 'name': 'withdrawalPeriod', 'type': 'uint32' },
120 |           { 'name': 'withdrawalValue', 'type': 'uint64' },
121 |           { 'name': 'owner', 'type': 'address',
122 |         }],
123 |         'name': 'locks', 'type': 'map(uint64,tuple)',
124 |       },
125 |       { 'name': 'vestingDonor', 'type': 'address' },
126 |       { 'name': 'lockDonor', 'type': 'address' },
127 |     ],
128 |   }],
129 |   'data': [],
130 |   'events': [],
131 | } as const; // NOTE: `as const` is very important here
132 | 
133 | myApp().catch(console.error);
134 | ```
135 | 
136 | ### Build
137 | 
138 | ```shell
139 | npm install
140 | 
141 | # Build as ts library
142 | # (output will be in the `dist` folder)
143 | npm run build
144 | 
145 | # Build as js library to use directly in <script> tags
146 | # (output will be in the `vanilla` folder)
147 | npm run build:vanilla
148 | ```
149 | 
150 | ## Contributing
151 | 
152 | We welcome contributions to the project! If you notice any issues or errors, feel free to open an issue or submit a pull request.
153 | 
154 | ## License
155 | 
156 | Licensed under GPL-3.0 license ([LICENSE](/LICENSE) or https://opensource.org/license/gpl-3-0/).
157 | 
158 | [latest version]: https://img.shields.io/npm/v/everscale-inpage-provider
159 | [npmjs.com]: https://www.npmjs.com/package/everscale-inpage-provider
160 | [docs badge]: https://img.shields.io/badge/docs-latest-brightgreen
161 | [docs]: https://broxus.github.io/everscale-inpage-provider/index.html
162 | 


--------------------------------------------------------------------------------
/src/adapters.ts:
--------------------------------------------------------------------------------
  1 | import type { Provider } from './index';
  2 | 
  3 | declare global {
  4 |     interface Window {
  5 |         __ever: Provider | undefined;
  6 |         __sparx: Provider | undefined;
  7 |         __hasEverscaleProvider: boolean | undefined;
  8 |     }
  9 | }
 10 | 
 11 | const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 12 | const ensurePageLoaded = !isBrowser || document.readyState === 'complete'
 13 |     ? Promise.resolve()
 14 |     : new Promise<void>(resolve => window.addEventListener('load', () => resolve()));
 15 | 
 16 | /**
 17 |  * Interface representing a provider adapter.
 18 |  * This interface defines the methods required to interact with a provider.
 19 |  * @category Provider
 20 |  */
 21 | export interface ProviderAdapter {
 22 |     /**
 23 |      * Retrieves the provider instance.
 24 |      */
 25 |     getProvider(): Promise<Provider | undefined> | Provider | undefined;
 26 | 
 27 |     /**
 28 |      * Checks if a provider is available.
 29 |      */
 30 |     hasProvider(): Promise<boolean> | boolean;
 31 | }
 32 | 
 33 | /**
 34 |  * @category Provider
 35 |  */
 36 | export function hasEverscaleProvider(): Promise<boolean> {
 37 |     if (!isBrowser) return Promise.resolve(false);
 38 |     return ensurePageLoaded.then(() => window.__hasEverscaleProvider === true);
 39 | }
 40 | 
 41 | /**
 42 |  * @category Provider
 43 |  */
 44 | export function hasSparxProvider(): Promise<boolean> {
 45 |     if (!isBrowser) return Promise.resolve(false);
 46 |     return ensurePageLoaded.then(() => !!window.__sparx);
 47 | }
 48 | 
 49 | /**
 50 |  * A static implementation of the `ProviderAdapter` interface that wraps a given provider instance or a promise that resolves to a provider.
 51 |  * This adapter always indicates the presence of a provider.
 52 |  * @category Provider
 53 |  * @implements {ProviderAdapter}
 54 |  */
 55 | export class StaticProviderAdapter implements ProviderAdapter {
 56 |     private readonly _provider: Promise<Provider> | Provider;
 57 | 
 58 |     constructor(provider: Promise<Provider> | Provider) {
 59 |         this._provider = provider;
 60 |     }
 61 | 
 62 |     public getProvider(): Promise<Provider> | Provider {
 63 |         return this._provider;
 64 |     }
 65 | 
 66 |     public hasProvider(): boolean {
 67 |         return true;
 68 |     }
 69 | }
 70 | 
 71 | /**
 72 |  * An implementation of the `ProviderAdapter` interface that wraps Ever Wallet provider.
 73 |  * @category Provider
 74 |  * @implements {ProviderAdapter}
 75 |  */
 76 | export class EverscaleProviderAdapter implements ProviderAdapter {
 77 |     public async getProvider(): Promise<Provider | undefined> {
 78 |         if (!(await this.hasProvider())) return;
 79 | 
 80 |         return new Promise<Provider | undefined>((resolve) => {
 81 |             if (window.__ever) {
 82 |                 resolve(window.__ever);
 83 |             } else {
 84 |                 window.addEventListener(
 85 |                     'ever#initialized',
 86 |                     _ => resolve(window.__ever),
 87 |                     { once: true },
 88 |                 );
 89 |             }
 90 |         });
 91 |     }
 92 | 
 93 |     public hasProvider(): Promise<boolean> {
 94 |         return hasEverscaleProvider();
 95 |     }
 96 | }
 97 | 
 98 | /**
 99 |  * An implementation of the `ProviderAdapter` interface that wraps Sparx provider.
100 |  * @category Provider
101 |  * @implements {ProviderAdapter}
102 |  */
103 | export class SparxProviderAdapter implements ProviderAdapter {
104 |     public async getProvider(): Promise<Provider | undefined> {
105 |         if (!(await this.hasProvider())) return;
106 | 
107 |         return new Promise<Provider | undefined>((resolve) => {
108 |             if (window.__sparx) {
109 |                 resolve(window.__sparx);
110 |             } else {
111 |                 window.addEventListener(
112 |                     'sparx#initialized',
113 |                     _ => resolve(window.__sparx),
114 |                     { once: true },
115 |                 );
116 |             }
117 |         });
118 |     }
119 | 
120 |     public hasProvider(): Promise<boolean> {
121 |         return hasSparxProvider();
122 |     }
123 | }
124 | 
125 | 
126 | /**
127 |  * The `FallbackProviderAdapter` class implements the `ProviderAdapter` interface
128 |  * and provides a mechanism to use multiple provider adapters in a fallback manner.
129 |  * It attempts to use the primary adapter first, and if it fails, it falls back to
130 |  * the subsequent adapters in the order they were provided.
131 |  *
132 |  * @category Provider
133 |  * @implements {ProviderAdapter}
134 |  */
135 | export class FallbackProviderAdapter implements ProviderAdapter {
136 |     private readonly _adapters: [ProviderAdapter, ...ProviderAdapter[]];
137 | 
138 |     constructor(adapter: ProviderAdapter, ...fallbacks: ProviderAdapter[]) {
139 |         this._adapters = [adapter, ...fallbacks];
140 |     }
141 | 
142 |     public async getProvider(): Promise<Provider | undefined> {
143 |         for (const adapter of this._adapters) {
144 |             const provider = await adapter.getProvider();
145 |             if (provider) return provider;
146 |         }
147 | 
148 |         return undefined;
149 |     }
150 | 
151 |     public async hasProvider(): Promise<boolean> {
152 |         for (const adapter of this._adapters) {
153 |             if (await adapter.hasProvider()) return true;
154 |         }
155 |         return false;
156 |     }
157 | }
158 | 
159 | export function isProviderAdapter(value: any): value is ProviderAdapter {
160 |     return !!value && 'getProvider' in value && 'hasProvider' in value;
161 | }
162 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
  1 | import { Transaction, TransactionsBatchInfo } from './models';
  2 | 
  3 | /**
  4 |  * @category Utils
  5 |  */
  6 | export type UniqueArray<T> = T extends readonly [infer X, ...infer Rest]
  7 |   ? InArray<Rest, X> extends true
  8 |     ? ['Encountered value with duplicates:', X]
  9 |     : readonly [X, ...UniqueArray<Rest>]
 10 |   : T
 11 | 
 12 | /**
 13 |  * @category Utils
 14 |  */
 15 | export type InArray<T, X> = T extends readonly [X, ...infer _Rest]
 16 |   ? true
 17 |   : T extends readonly [X]
 18 |     ? true
 19 |     : T extends readonly [infer _, ...infer Rest]
 20 |       ? InArray<Rest, X>
 21 |       : false
 22 | 
 23 | /**
 24 |  * @category Utils
 25 |  */
 26 | export type ArrayItemType<T extends readonly unknown[]> = T extends readonly (infer Ts)[] ? Ts : never;
 27 | 
 28 | /**
 29 |  * @category Utils
 30 |  */
 31 | export class Address {
 32 |   private readonly _address: string;
 33 | 
 34 |   constructor(address: string) {
 35 |     this._address = address;
 36 |   }
 37 | 
 38 |   public toString(): string {
 39 |     return this._address;
 40 |   }
 41 | 
 42 |   public toJSON(): string {
 43 |     return this._address;
 44 |   }
 45 | 
 46 |   public equals = (other: Address | string): boolean => this._equals(other);
 47 | 
 48 |   private _equals(other: Address | string): boolean {
 49 |     if (typeof other === 'string') {
 50 |       return this._address === other;
 51 |     } else {
 52 |       return this._address === other?._address;
 53 |     }
 54 |   }
 55 | }
 56 | 
 57 | /**
 58 |  * Check whether the provider object is instance of `Address`,
 59 |  * handling the case of duplicated dependencies.
 60 |  */
 61 | export function isAddressObject(address: object | null): boolean {
 62 |   return (
 63 |     address != null &&
 64 |     (address instanceof Address ||
 65 |       Object.getPrototypeOf(address).constructor.name === Address.prototype.constructor.name)
 66 |   );
 67 | }
 68 | 
 69 | /**
 70 |  * @category Utils
 71 |  */
 72 | export class AddressLiteral<T extends string> extends Address {
 73 |   constructor(address: CheckAddress<T>) {
 74 |     super(address);
 75 |   }
 76 | }
 77 | 
 78 | /**
 79 |  * @category Utils
 80 |  */
 81 | export type CheckAddress<T extends string> = AddressImpl<T, Lowercase<T>>;
 82 | 
 83 | type AddressPrefix = '0:' | '-1:'
 84 | type AddressImpl<T, Tl extends string> = Tl extends `${AddressPrefix}${infer Hash}`
 85 |   ? true extends IsHexString<Hash, []>
 86 |     ? T : never
 87 |   : never;
 88 | 
 89 | type HexSymbol = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
 90 | type HexByte = `${HexSymbol}${HexSymbol}`
 91 | type IsHexString<T extends string, L extends readonly number[]> =
 92 |   T extends `${HexByte}${infer Tail}`
 93 |     ? IsHexString<Tail, [...L, 0]>
 94 |     : T extends '' ? L['length'] extends 32 ? true : never : never
 95 | 
 96 | /**
 97 |  * @category Utils
 98 |  */
 99 | export class MessageExpiredException extends Error {
100 |   constructor(public readonly address: Address, public readonly hash: string) {
101 |     super('Message expired');
102 |   }
103 | }
104 | 
105 | export class DelayedTransactions {
106 |   private readonly transactions: Map<string, {
107 |     promise: Promise<Transaction | undefined>,
108 |     resolve: (transaction?: Transaction) => void,
109 |     reject: () => void,
110 |   }> = new Map();
111 | 
112 |   public async waitTransaction(address: Address, hash: string): Promise<Transaction> {
113 |     let transaction = this.transactions.get(hash)?.promise;
114 |     if (transaction == null) {
115 |       let resolve: (transaction?: Transaction) => void;
116 |       let reject: () => void;
117 |       transaction = new Promise<Transaction | undefined>((promiseResolve, promiseReject) => {
118 |         resolve = (tx) => promiseResolve(tx);
119 |         reject = () => promiseReject();
120 |       });
121 |       this.transactions.set(hash, {
122 |         promise: transaction,
123 |         resolve: resolve!,
124 |         reject: reject!,
125 |       });
126 |     }
127 | 
128 |     const tx = await transaction;
129 |     if (tx == null) {
130 |       throw new MessageExpiredException(address, hash);
131 |     }
132 |     return tx;
133 |   }
134 | 
135 |   public fillTransaction(hash: string, transaction?: Transaction) {
136 |     const pendingTransaction = this.transactions.get(hash);
137 |     if (pendingTransaction != null) {
138 |       pendingTransaction.resolve(transaction);
139 |     } else {
140 |       this.transactions.set(hash, {
141 |         promise: Promise.resolve(transaction),
142 |         resolve: () => { /* do nothing */
143 |         },
144 |         reject: () => { /* do nothing */
145 |         },
146 |       });
147 |     }
148 |   }
149 | }
150 | 
151 | /**
152 |  * @category Utils
153 |  */
154 | export class Semaphore {
155 |   private tasks: (() => void)[] = [];
156 |   count: number;
157 | 
158 |   constructor(count: number) {
159 |     this.count = count;
160 |   }
161 | 
162 |   public acquire(): Promise<() => void> {
163 |     return new Promise<() => void>((res, _rej) => {
164 |       this.tasks.push(() => {
165 |         let released = false;
166 |         res(() => {
167 |           if (!released) {
168 |             released = true;
169 |             this.count++;
170 |             this.sched();
171 |           }
172 |         });
173 |       });
174 |       nextTick(this.sched);
175 |     });
176 |   }
177 | 
178 |   public releaseAll() {
179 |     while (this.tasks.length > 0) {
180 |       this.tasks.shift()?.();
181 |     }
182 |   }
183 | 
184 |   sched = () => {
185 |     if (this.count > 0 && this.tasks.length > 0) {
186 |       this.count--;
187 |       this.tasks.shift()?.();
188 |     }
189 |   };
190 | }
191 | 
192 | function byObserver(Observer: any) {
193 |   const node = document.createTextNode('');
194 |   let queue: any, currentQueue: any, bit = 0, i = 0;
195 |   new Observer(function() {
196 |     let callback;
197 |     if (!queue) {
198 |       if (!currentQueue) return;
199 |       queue = currentQueue;
200 |     } else if (currentQueue) {
201 |       queue = currentQueue.slice(i).concat(queue);
202 |     }
203 |     currentQueue = queue;
204 |     queue = null;
205 |     i = 0;
206 |     if (typeof currentQueue === 'function') {
207 |       callback = currentQueue;
208 |       currentQueue = null;
209 |       callback();
210 |       return;
211 |     }
212 |     node.data = (bit = ++bit % 2) as any;
213 |     while (i < currentQueue.length) {
214 |       callback = currentQueue[i];
215 |       i++;
216 |       if (i === currentQueue.length) currentQueue = null;
217 |       callback();
218 |     }
219 |   }).observe(node, { characterData: true });
220 | 
221 |   return function(fn: any) {
222 |     if (queue) {
223 |       if (typeof queue === 'function') queue = [queue, fn];
224 |       else queue.push(fn);
225 |       return;
226 |     }
227 |     queue = fn;
228 |     node.data = (bit = ++bit % 2) as any;
229 |   };
230 | }
231 | 
232 | const nextTick = (function() {
233 |   // queueMicrotask
234 |   if (typeof queueMicrotask === 'function') {
235 |     return queueMicrotask;
236 |   }
237 | 
238 |   // MutationObserver
239 |   if ((typeof document === 'object') && document) {
240 |     if (typeof MutationObserver === 'function') return byObserver(MutationObserver);
241 |     if (typeof (window as any).WebKitMutationObserver === 'function') return byObserver((window as any).WebKitMutationObserver);
242 |   }
243 | 
244 |   /* @ts-ignore */
245 |   if (typeof setImmediate === 'function') {
246 |     /* @ts-ignore */
247 |     return setImmediate;
248 |   }
249 | 
250 |   if ((typeof setTimeout === 'function') || (typeof setTimeout === 'object')) {
251 |     return function(cb: any) {
252 |       setTimeout(cb, 0);
253 |     };
254 |   }
255 | 
256 |   throw new Error('No `nextTick` implementation found');
257 | }());
258 | 
259 | /**
260 |  * @category Utils
261 |  */
262 | export const LT_COLLATOR: Intl.Collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
263 | 
264 | /**
265 |  * Modifies knownTransactions array, merging it with new transactions.
266 |  * All arrays are assumed to be sorted by descending logical time.
267 |  *
268 |  * > Note! This method does not remove duplicates.
269 |  *
270 |  * @param knownTransactions
271 |  * @param newTransactions
272 |  * @param info
273 |  *
274 |  * @category Utils
275 |  */
276 | export function mergeTransactions<Addr>(
277 |   knownTransactions: Transaction<Addr>[],
278 |   newTransactions: Transaction<Addr>[],
279 |   info: TransactionsBatchInfo,
280 | ): Transaction<Addr>[] {
281 |   if (info.batchType === 'old') {
282 |     knownTransactions.push(...newTransactions);
283 |     return knownTransactions;
284 |   }
285 | 
286 |   if (knownTransactions.length === 0) {
287 |     knownTransactions.push(...newTransactions);
288 |     return knownTransactions;
289 |   }
290 | 
291 |   // Example:
292 |   // known lts: [N, N-1, N-2, N-3, (!) N-10,...]
293 |   // new lts: [N-4, N-5]
294 |   // batch info: { minLt: N-5, maxLt: N-4, batchType: 'new' }
295 | 
296 |   // 1. Skip indices until known transaction lt is greater than the biggest in the batch
297 |   let i = 0;
298 |   while (
299 |     i < knownTransactions.length &&
300 |     LT_COLLATOR.compare(knownTransactions[i].id.lt, info.maxLt) >= 0
301 |     ) {
302 |     ++i;
303 |   }
304 | 
305 |   // 2. Insert new transactions
306 |   knownTransactions.splice(i, 0, ...newTransactions);
307 |   return knownTransactions;
308 | }
309 | 
310 | const MAX = 4294967295;
311 | 
312 | let idCounter = Math.floor(Math.random() * MAX);
313 | 
314 | export function getUniqueId(): number {
315 |   idCounter = (idCounter + 1) % MAX;
316 |   return idCounter;
317 | }
318 | 


--------------------------------------------------------------------------------
/src/models.ts:
--------------------------------------------------------------------------------
  1 | import { Address, ArrayItemType, isAddressObject } from './utils';
  2 | 
  3 | /* Account stuff */
  4 | 
  5 | /**
  6 |  * @category Models
  7 |  */
  8 | export interface ContractState {
  9 |   balance: string;
 10 |   genTimings: GenTimings;
 11 |   lastTransactionId?: LastTransactionId;
 12 |   isDeployed: boolean;
 13 |   codeHash?: string;
 14 | }
 15 | 
 16 | /**
 17 |  * @category Models
 18 |  */
 19 | export interface FullContractState {
 20 |   boc: string;
 21 |   balance: string;
 22 |   genTimings: GenTimings;
 23 |   lastTransactionId?: LastTransactionId;
 24 |   isDeployed: boolean;
 25 |   codeHash?: string;
 26 | }
 27 | 
 28 | /**
 29 |  * @category Models
 30 |  */
 31 | export type GenTimings = {
 32 |   genLt: string;
 33 |   genUtime: number;
 34 | };
 35 | 
 36 | /**
 37 |  * @category Models
 38 |  */
 39 | export type ContractUpdatesSubscription = {
 40 |   /**
 41 |    * Whether to listen contract state updates
 42 |    */
 43 |   state: boolean;
 44 |   /**
 45 |    * Whether to listen new contract transactions
 46 |    */
 47 |   transactions: boolean;
 48 | };
 49 | 
 50 | /**
 51 |  * @category Models
 52 |  */
 53 | export type TransactionsBatchInfo = {
 54 |   minLt: string;
 55 |   maxLt: string;
 56 |   batchType: TransactionsBatchType;
 57 | };
 58 | 
 59 | /**
 60 |  * @category Models
 61 |  */
 62 | export type TransactionsBatchType = 'old' | 'new';
 63 | 
 64 | /**
 65 |  * @category Models
 66 |  */
 67 | export type Transaction<Addr = Address> = {
 68 |   id: TransactionId;
 69 |   prevTransactionId?: TransactionId;
 70 |   createdAt: number;
 71 |   aborted: boolean;
 72 |   exitCode?: number;
 73 |   resultCode?: number;
 74 |   origStatus: AccountStatus;
 75 |   endStatus: AccountStatus;
 76 |   totalFees: string;
 77 |   inMessage: Message<Addr>;
 78 |   outMessages: Message<Addr>[];
 79 | };
 80 | 
 81 | /**
 82 |  * @category Models
 83 |  */
 84 | export type TransactionWithAccount<Addr = Address> = Transaction<Addr> & { account: Addr };
 85 | 
 86 | /**
 87 |  * @category Models
 88 |  */
 89 | export type RawTransaction = Transaction<string>;
 90 | 
 91 | /**
 92 |  * @category Models
 93 |  */
 94 | export function serializeTransaction(transaction: Transaction): RawTransaction {
 95 |   // NOTE: deep copy to prevent sending objects with prototypes through the channel
 96 |   return {
 97 |     id: {
 98 |       hash: transaction.id.hash,
 99 |       lt: transaction.id.lt,
100 |     },
101 |     prevTransactionId:
102 |       transaction.prevTransactionId != null
103 |         ? {
104 |             hash: transaction.prevTransactionId.hash,
105 |             lt: transaction.prevTransactionId.lt,
106 |           }
107 |         : undefined,
108 |     createdAt: transaction.createdAt,
109 |     aborted: transaction.aborted,
110 |     exitCode: transaction.exitCode,
111 |     resultCode: transaction.resultCode,
112 |     origStatus: transaction.origStatus,
113 |     endStatus: transaction.endStatus,
114 |     totalFees: transaction.totalFees,
115 |     inMessage: serializeMessage(transaction.inMessage),
116 |     outMessages: transaction.outMessages.map(serializeMessage),
117 |   };
118 | }
119 | 
120 | /**
121 |  * @category Models
122 |  */
123 | export function parseTransaction(transaction: RawTransaction): Transaction {
124 |   return {
125 |     ...transaction,
126 |     inMessage: parseMessage(transaction.inMessage),
127 |     outMessages: transaction.outMessages.map(parseMessage),
128 |   };
129 | }
130 | 
131 | /**
132 |  * @category Models
133 |  */
134 | export type Message<Addr = Address> = {
135 |   hash: string;
136 |   src?: Addr;
137 |   dst?: Addr;
138 |   value: string;
139 |   bounce: boolean;
140 |   bounced: boolean;
141 |   body?: string;
142 |   bodyHash?: string;
143 | };
144 | 
145 | /**
146 |  * @category Models
147 |  */
148 | export type RawMessage = Message<string>;
149 | 
150 | /**
151 |  * @category Models
152 |  */
153 | export function serializeMessage(message: Message): RawMessage {
154 |   // NOTE: deep copy to prevent sending objects with prototypes through the channel
155 |   return {
156 |     hash: message.hash,
157 |     src: message.src ? message.src.toString() : undefined,
158 |     dst: message.dst ? message.dst.toString() : undefined,
159 |     value: message.value,
160 |     bounce: message.bounce,
161 |     bounced: message.bounced,
162 |     body: message.body,
163 |     bodyHash: message.bodyHash,
164 |   };
165 | }
166 | 
167 | /**
168 |  * @category Models
169 |  */
170 | export function parseMessage(message: RawMessage): Message {
171 |   return {
172 |     ...message,
173 |     src: message.src ? new Address(message.src) : undefined,
174 |     dst: message.dst ? new Address(message.dst) : undefined,
175 |   };
176 | }
177 | 
178 | /**
179 |  * @category Models
180 |  */
181 | export type DelayedMessage<Addr = Address> = {
182 |   /**
183 |    * External message hash
184 |    */
185 |   hash: string;
186 |   /**
187 |    * Destination account address (`sender` for `sendMessageDelayed`, `recipient` for `sendExternalMessageDelayed`)
188 |    */
189 |   account: Addr;
190 |   /**
191 |    * Message expiration timestamp
192 |    */
193 |   expireAt: number;
194 | };
195 | 
196 | /**
197 |  * @category Models
198 |  */
199 | export type AccountStatus = 'uninit' | 'frozen' | 'active' | 'nonexist';
200 | 
201 | /**
202 |  * @category Models
203 |  */
204 | export type LastTransactionId = {
205 |   isExact: boolean;
206 |   lt: string;
207 |   hash?: string;
208 | };
209 | 
210 | /**
211 |  * @category Models
212 |  */
213 | export type TransactionId = {
214 |   lt: string;
215 |   hash: string;
216 | };
217 | 
218 | /* Permissions stuff */
219 | 
220 | /**
221 |  * @category Models
222 |  */
223 | export type Permissions<Addr = Address> = {
224 |   basic: true;
225 |   accountInteraction: {
226 |     address: Addr;
227 |     publicKey: string;
228 |     contractType: string;
229 |   };
230 | };
231 | 
232 | /**
233 |  * @category Models
234 |  */
235 | export type RawPermissions = Permissions<string>;
236 | 
237 | /**
238 |  * @category Models
239 |  */
240 | export function parsePermissions(permissions: Partial<RawPermissions>): Partial<Permissions> {
241 |   return {
242 |     ...permissions,
243 |     accountInteraction: permissions.accountInteraction
244 |       ? parseAccountInteraction(permissions.accountInteraction)
245 |       : undefined,
246 |   };
247 | }
248 | 
249 | /**
250 |  * @category Models
251 |  */
252 | export function parseAccountInteraction(
253 |   accountInteraction: Required<RawPermissions>['accountInteraction'],
254 | ): Required<Permissions>['accountInteraction'] {
255 |   return {
256 |     ...accountInteraction,
257 |     address: new Address(accountInteraction.address),
258 |   };
259 | }
260 | 
261 | /**
262 |  * @category Models
263 |  */
264 | export type Permission = keyof Permissions;
265 | 
266 | /**
267 |  * @category Models
268 |  */
269 | export type PermissionData<T extends Permission, Addr = Address> = Permissions<Addr>[T];
270 | 
271 | /* Assets stuff */
272 | 
273 | /**
274 |  * @category Models
275 |  */
276 | export type AssetType = 'tip3_token';
277 | 
278 | /**
279 |  * @category Models
280 |  */
281 | export type AssetTypeParams<T extends AssetType, Addr = Address> = T extends 'tip3_token'
282 |   ? {
283 |       rootContract: Addr;
284 |     }
285 |   : never;
286 | 
287 | /**
288 |  * @category Models
289 |  */
290 | export type EncryptionAlgorithm = 'ChaCha20Poly1305';
291 | 
292 | /**
293 |  * @category Models
294 |  */
295 | export type EncryptedData = {
296 |   algorithm: EncryptionAlgorithm;
297 |   /**
298 |    * Hex encoded encryptor's public key
299 |    */
300 |   sourcePublicKey: string;
301 |   /**
302 |    * Hex encoded recipient public key
303 |    */
304 |   recipientPublicKey: string;
305 |   /**
306 |    * Base64 encoded data
307 |    */
308 |   data: string;
309 |   /**
310 |    * Base64 encoded nonce
311 |    */
312 |   nonce: string;
313 | };
314 | 
315 | /* Network stuff */
316 | 
317 | /**
318 |  * @category Models
319 |  */
320 | export type NetworkDescription = {
321 |   globalId: number;
322 |   capabilities: string;
323 |   signatureId: number | undefined;
324 | };
325 | 
326 | /**
327 |  * @category Models
328 |  */
329 | export type NetworkConfig = {
330 |   symbol?: string;
331 |   decimals?: number;
332 |   explorerBaseUrl?: string;
333 |   tokensManifestUrl?: string;
334 | };
335 | 
336 | /**
337 |  * @category Models
338 |  */
339 | export type GqlSocketParams = {
340 |   /**
341 |    * Path to graphql api endpoints
342 |    */
343 |   endpoints: string[]
344 |   /**
345 |    * Frequency of sync latency detection
346 |    */
347 |   latencyDetectionInterval: number
348 |   /**
349 |    * Maximum value for the endpoint's blockchain data sync latency
350 |    */
351 |   maxLatency: number
352 |   /**
353 |    * Gql node type
354 |    */
355 |   local: boolean
356 | };
357 | 
358 | /**
359 |  * @category Models
360 |  */
361 | export type JrpcSocketParams = {
362 |   /**
363 |    * Path to jrpc api endpoint
364 |    */
365 |   endpoint: string
366 | };
367 | 
368 | /**
369 |  * @category Models
370 |  */
371 | export type ProtoSocketParams = JrpcSocketParams & {};
372 | 
373 | export type GqlConnection = { type: 'graphql', data: GqlSocketParams };
374 | export type JrpcConnection = { type: 'jrpc', data: JrpcSocketParams };
375 | export type ProtoConnection = { type: 'proto', data: ProtoSocketParams };
376 | 
377 | /**
378 |  * @category Models
379 |  */
380 | export type Network = {
381 |   name: string;
382 |   description: NetworkDescription;
383 |   connection: GqlConnection | JrpcConnection | ProtoConnection | any;
384 |   config: NetworkConfig;
385 | };
386 | 
387 | /**
388 |  * @category Models
389 |  */
390 | export type AddNetwork = {
391 |   name: string;
392 |   networkId: number;
393 |   connection: GqlConnection | JrpcConnection | ProtoConnection | any;
394 |   config?: NetworkConfig;
395 | };
396 | 
397 | /**
398 |  * @category Models
399 |  */
400 | export type IgnoreTransactionTreeSimulationError<Addr = Address> = {
401 |   /**
402 |    * Contract address.
403 |    * If not specified, the error will be ignored for all contracts.
404 |    */
405 |   address?: Addr;
406 |   /**
407 |    * Error code to be ignored
408 |    */
409 |   code: number;
410 | };
411 | 
412 | /* ABI stuff */
413 | 
414 | /**
415 |  * @category Models
416 |  */
417 | export type AbiVersion = '1.0' | '2.0' | '2.1' | '2.2' | '2.3';
418 | 
419 | /**
420 |  * @category Models
421 |  */
422 | // NOTE: `boolean` must be after `string` due to JS being itself - https://github.com/vuejs/core/issues/9253
423 | export type TokenValue<Addr = Address> =
424 |   | null
425 |   | string
426 |   | number
427 |   | Addr
428 |   | boolean
429 |   | { [K in string]: TokenValue<Addr> }
430 |   | TokenValue<Addr>[]
431 |   | (readonly [TokenValue<Addr>, TokenValue<Addr>])[];
432 | 
433 | /**
434 |  * @category Models
435 |  */
436 | export type RawTokenValue = TokenValue<string>;
437 | 
438 | /**
439 |  * @category Models
440 |  */
441 | export type TokensObject<Addr = Address> = { [K in string]: TokenValue<Addr> };
442 | 
443 | /**
444 |  * @category Models
445 |  */
446 | export type RawTokensObject = TokensObject<string>;
447 | 
448 | /**
449 |  * @category Models
450 |  */
451 | export type FunctionCall<Addr = Address> = {
452 |   /**
453 |    * Contract ABI
454 |    */
455 |   abi: string;
456 |   /**
457 |    * Specific method from specified contract ABI
458 |    */
459 |   method: string;
460 |   /**
461 |    * Method arguments
462 |    */
463 |   params: TokensObject<Addr>;
464 | };
465 | 
466 | /**
467 |  * @category Models
468 |  */
469 | export type GetterCall<Addr = Address> = {
470 |   /**
471 |    * Contract ABI
472 |    */
473 |   abi: string;
474 |   /**
475 |    * Specific getter from specified contract ABI
476 |    */
477 |   getter: string;
478 |   /**
479 |    * Getter arguments
480 |    */
481 |   params: TokensObject<Addr>;
482 | };
483 | 
484 | type AbiParamKindUint = 'uint8' | 'uint16' | 'uint24' | 'uint32' | 'uint64' | 'uint128' | 'uint160' | 'uint256';
485 | type AbiParamKindInt = 'int8' | 'int16' | 'int24' | 'int32' | 'int64' | 'int128' | 'int160' | 'int256';
486 | type AbiParamKindVarUint = 'varuint16' | 'varuint32';
487 | type AbiParamKindVarInt = 'varint16' | 'varint32';
488 | type AbiParamKindTuple = 'tuple';
489 | type AbiParamKindBool = 'bool';
490 | type AbiParamKindCell = 'cell';
491 | type AbiParamKindAddress = 'address';
492 | type AbiParamKindBytes = 'bytes';
493 | type AbiParamKindFixedBytes = `fixedbytes${NonZeroDigit | `${'1' | '2'}${Digit}` | '30' | '31' | '32'}`;
494 | type AbiParamKindString = 'string';
495 | type AbiParamKindGram = 'gram';
496 | type AbiParamKindTime = 'time';
497 | type AbiParamKindExpire = 'expire';
498 | type AbiParamKindPublicKey = 'pubkey';
499 | type AbiParamKindArray = `${AbiParamKind}[]`;
500 | 
501 | type AbiParamKindMapKey = AbiParamKindInt | AbiParamKindUint | AbiParamKindAddress;
502 | type AbiParamKindMap = `map(${AbiParamKindMapKey},${AbiParamKind | `${AbiParamKind}[]`})`;
503 | 
504 | type AbiParamOptional = `optional(${AbiParamKind})`;
505 | type AbiParamRef = `ref(${AbiParamKind})`;
506 | type AbiParamOptionalRef = `optional(ref(${AbiParamKind}))`;
507 | type AbiParamRefOptional = `ref(optional(${AbiParamKind}))`;
508 | 
509 | type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
510 | type NonZeroDigit = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
511 | 
512 | /**
513 |  * @category Models
514 |  */
515 | export type AbiParamKind =
516 |   | AbiParamKindUint
517 |   | AbiParamKindInt
518 |   | AbiParamKindVarUint
519 |   | AbiParamKindVarInt
520 |   | AbiParamKindTuple
521 |   | AbiParamKindBool
522 |   | AbiParamKindCell
523 |   | AbiParamKindAddress
524 |   | AbiParamKindBytes
525 |   | AbiParamKindFixedBytes
526 |   | AbiParamKindString
527 |   | AbiParamKindGram
528 |   | AbiParamKindTime
529 |   | AbiParamKindExpire
530 |   | AbiParamKindPublicKey;
531 | 
532 | /**
533 |  * @category Models
534 |  */
535 | export type AbiParam = {
536 |   name: string;
537 |   type:
538 |     | AbiParamKind
539 |     | AbiParamKindMap
540 |     | AbiParamKindArray
541 |     | AbiParamOptional
542 |     | AbiParamRef
543 |     | AbiParamOptionalRef
544 |     | AbiParamRefOptional;
545 |   components?: AbiParam[];
546 | };
547 | 
548 | /**
549 |  * @category Models
550 |  */
551 | export type ReadonlyAbiParam = {
552 |   name: string;
553 |   type:
554 |     | AbiParamKind
555 |     | AbiParamKindMap
556 |     | AbiParamKindArray
557 |     | AbiParamOptional
558 |     | AbiParamRef
559 |     | AbiParamOptionalRef
560 |     | AbiParamRefOptional;
561 |   components?: readonly ReadonlyAbiParam[];
562 | };
563 | 
564 | /**
565 |  * @category Models
566 |  */
567 | export function serializeTokensObject(object: TokensObject): RawTokensObject {
568 |   return serializeTokenValue(object as TokenValue) as RawTokensObject;
569 | }
570 | 
571 | function serializeTokenValue(token: TokenValue): RawTokenValue {
572 |   if (typeof token === 'object' && isAddressObject(token)) {
573 |     return token!.toString();
574 |   }
575 | 
576 |   if (Array.isArray(token)) {
577 |     const result: RawTokenValue[] = [];
578 |     for (const item of token as TokenValue[]) {
579 |       result.push(serializeTokenValue(item));
580 |     }
581 |     return result;
582 |   } else if (token != null && typeof token === 'object') {
583 |     const result: { [name: string]: RawTokenValue } = {};
584 |     for (const [key, value] of Object.entries(token)) {
585 |       result[key] = serializeTokenValue(value);
586 |     }
587 |     return result;
588 |   } else {
589 |     return token;
590 |   }
591 | }
592 | 
593 | /**
594 |  * @category Models
595 |  */
596 | export function serializeIgnoreCode(
597 |   object: IgnoreTransactionTreeSimulationError,
598 | ): IgnoreTransactionTreeSimulationError<string> {
599 |   return { address: object.address?.toString(), code: object.code };
600 | }
601 | 
602 | /**
603 |  * @category Models
604 |  */
605 | export function parseTokensObject(params: AbiParam[], object: RawTokensObject): TokensObject {
606 |   const result: TokensObject = {};
607 |   for (const param of params) {
608 |     result[param.name] = parseTokenValue(param, object[param.name]);
609 |   }
610 |   return result;
611 | }
612 | 
613 | /**
614 |  * @category Models
615 |  */
616 | export function parsePartialTokensObject(params: AbiParam[], object: Partial<RawTokensObject>): TokensObject {
617 |   const result: TokensObject = {};
618 |   for (const param of params) {
619 |     if (Object.prototype.hasOwnProperty.call(object, param.name)) {
620 |       result[param.name] = parseTokenValue(param, !object[param.name]);
621 |     }
622 |   }
623 |   return result;
624 | }
625 | 
626 | function parseTokenValue(param: AbiParam, token: RawTokenValue): TokenValue {
627 |   if (!param.type.startsWith('map')) {
628 |     const isArray = param.type.endsWith('[]');
629 |     const isOptional = !isArray && param.type.startsWith('optional');
630 | 
631 |     const rawType = (
632 |       isArray ? param.type.slice(0, -2) : isOptional ? param.type.slice(9, -1) : param.type
633 |     ) as AbiParamKind;
634 | 
635 |     if (isArray) {
636 |       const rawParam = { name: param.name, type: rawType, components: param.components } as AbiParam;
637 | 
638 |       const result: TokenValue[] = [];
639 |       for (const item of token as TokenValue<string>[]) {
640 |         result.push(parseTokenValue(rawParam, item));
641 |       }
642 |       return result;
643 |     } else if (isOptional) {
644 |       if (token == null) {
645 |         return null;
646 |       } else {
647 |         const rawParam = { name: param.name, type: rawType, components: param.components } as AbiParam;
648 |         return parseTokenValue(rawParam, token);
649 |       }
650 |     } else if (rawType === 'tuple') {
651 |       type TokenValueTuple<Addr> = { [K in string]: TokenValue<Addr> };
652 | 
653 |       const result: TokenValueTuple<Address> = {};
654 |       if (param.components != null) {
655 |         for (const component of param.components) {
656 |           result[component.name] = parseTokenValue(component, (token as TokenValueTuple<string>)[component.name]);
657 |         }
658 |       }
659 |       return result;
660 |     } else if (rawType === 'address') {
661 |       return new Address(token as string) as TokenValue;
662 |     } else {
663 |       return token;
664 |     }
665 |   } else {
666 |     type TokenValueMap<Addr> = (readonly [TokenValue<Addr>, TokenValue<Addr>])[];
667 | 
668 |     const valueTypeIndex = param.type.indexOf(',');
669 |     const keyType = param.type.slice(4, valueTypeIndex);
670 |     const valueType = param.type.slice(valueTypeIndex + 1, -1);
671 | 
672 |     const result: TokenValueMap<Address> = [];
673 |     for (const [key, value] of token as unknown as TokenValueMap<string>) {
674 |       result.push([
675 |         parseTokenValue(
676 |           {
677 |             name: '',
678 |             type: keyType as AbiParamKind,
679 |           },
680 |           key,
681 |         ),
682 |         parseTokenValue(
683 |           {
684 |             name: '',
685 |             type: valueType as AbiParamKind,
686 |             components: param.components,
687 |           },
688 |           value,
689 |         ),
690 |       ]);
691 |     }
692 |     return result;
693 |   }
694 | }
695 | 
696 | // prettier-ignore
697 | type InputTokenValue<T, C> =
698 |   T extends AbiParamKindUint | AbiParamKindInt | AbiParamKindVarUint | AbiParamKindVarInt | AbiParamKindGram | AbiParamKindTime | AbiParamKindExpire ? string | number
699 |     : T extends AbiParamKindBool ? boolean
700 |       : T extends AbiParamKindCell | AbiParamKindBytes | AbiParamKindFixedBytes | AbiParamKindString | AbiParamKindPublicKey ? string
701 |         : T extends AbiParamKindAddress ? Address
702 |           : T extends AbiParamKindTuple ? MergeInputObjectsArray<C>
703 |             : T extends `${infer K}[]` ? InputTokenValue<K, C>[]
704 |               : T extends `map(${infer K},${infer V})` ? (readonly [InputTokenValue<K, undefined>, InputTokenValue<V, C>])[]
705 |                 : T extends `optional(${infer V})` | `ref(optional(${infer V}))` | `optional(ref(${infer V}))` ? (InputTokenValue<V, C> | null)
706 |                   : T extends `ref(${infer V})` ? InputTokenValue<V, C>
707 |                     : never;
708 | 
709 | // prettier-ignore
710 | type OutputTokenValue<T, C> =
711 |   T extends AbiParamKindUint | AbiParamKindInt | AbiParamKindVarUint | AbiParamKindVarInt | AbiParamKindGram | AbiParamKindTime | AbiParamKindCell | AbiParamKindBytes | AbiParamKindFixedBytes | AbiParamKindString | AbiParamKindPublicKey ? string
712 |     : T extends AbiParamKindExpire ? number
713 |       : T extends AbiParamKindBool ? boolean
714 |         : T extends AbiParamKindAddress ? Address
715 |           : T extends AbiParamKindTuple ? MergeOutputObjectsArray<C>
716 |             : T extends `${infer K}[]` ? OutputTokenValue<K, C>[]
717 |               : T extends `map(${infer K},${infer V})` ? (readonly [OutputTokenValue<K, undefined>, OutputTokenValue<V, C>])[]
718 |                 : T extends `optional(${infer V})` | `ref(optional(${infer V}))` | `optional(ref(${infer V}))` ? (OutputTokenValue<V, C> | null)
719 |                   : T extends `ref(${infer V})` ? OutputTokenValue<V, C>
720 |                     : never;
721 | 
722 | /**
723 |  * @category Models
724 |  */
725 | export type InputTokenObject<O> = O extends { name: infer K; type: infer T; components?: infer C }
726 |   ? K extends string
727 |     ? { [P in K]: InputTokenValue<T, C> }
728 |     : never
729 |   : never;
730 | 
731 | /**
732 |  * @category Models
733 |  */
734 | export type OutputTokenObject<O> = O extends { name: infer K; type: infer T; components?: infer C }
735 |   ? K extends string
736 |     ? { [P in K]: OutputTokenValue<T, C> }
737 |     : never
738 |   : never;
739 | 
740 | /**
741 |  * @category Models
742 |  */
743 | export type MergeInputObjectsArray<A> = A extends readonly [infer T, ...infer Ts]
744 |   ? InputTokenObject<T> & MergeInputObjectsArray<[...Ts]>
745 |   : A extends readonly [infer T]
746 |   ? InputTokenObject<T>
747 |   : A extends readonly []
748 |   ? {}
749 |   : never;
750 | 
751 | /**
752 |  * @category Models
753 |  */
754 | export type MergeOutputObjectsArray<A> = A extends readonly [infer T, ...infer Ts]
755 |   ? OutputTokenObject<T> & MergeOutputObjectsArray<[...Ts]>
756 |   : A extends readonly [infer T]
757 |   ? OutputTokenObject<T>
758 |   : A extends readonly []
759 |   ? {}
760 |   : never;
761 | 
762 | /**
763 |  * @category Models
764 |  */
765 | export type AbiFunctions<C> = C extends { functions: infer F }
766 |   ? F extends readonly unknown[]
767 |     ? ArrayItemType<F>
768 |     : never
769 |   : never;
770 | 
771 | /**
772 |  * @category Models
773 |  */
774 | export type AbiGetters<C> = C extends { getters: infer F }
775 |   ? F extends readonly unknown[]
776 |     ? ArrayItemType<F>
777 |     : never
778 |   : never;
779 | 
780 | /**
781 |  * @category Models
782 |  */
783 | export type AbiEvents<C> = C extends { events: infer E }
784 |   ? E extends readonly unknown[]
785 |     ? ArrayItemType<E>
786 |     : never
787 |   : never;
788 | 
789 | /**
790 |  * @category Models
791 |  */
792 | export type AbiFields<C> = C extends { fields: infer F } ? F : never;
793 | 
794 | /**
795 |  * @category Models
796 |  */
797 | export type AbiFunction<C, T extends AbiFunctionName<C>> = Extract<AbiFunctions<C>, { name: T }>;
798 | /**
799 |  * @category Models
800 |  */
801 | export type AbiGetter<C, T extends AbiGetterName<C>> = Extract<AbiGetters<C>, { name: T }>;
802 | /**
803 |  * @category Models
804 |  */
805 | export type AbiEvent<C, T extends AbiEventName<C>> = Extract<AbiEvents<C>, { name: T }>;
806 | 
807 | /**
808 |  * @category Models
809 |  */
810 | export type AbiFunctionName<C> = AbiFunctions<C>['name'];
811 | /**
812 |  * @category Models
813 |  */
814 | export type AbiGetterName<C> = AbiGetters<C>['name'];
815 | /**
816 |  * @category Models
817 |  */
818 | export type AbiEventName<C> = AbiEvents<C>['name'];
819 | /**
820 |  * @category Models
821 |  */
822 | export type AbiFieldName<C> = keyof DecodedAbiFields<C>;
823 | 
824 | /**
825 |  * @category Models
826 |  */
827 | export type AbiFunctionInputs<C, T extends AbiFunctionName<C>> = MergeInputObjectsArray<AbiFunction<C, T>['inputs']>;
828 | 
829 | /**
830 |  * @category Models
831 |  */
832 | export type AbiFunctionInputsWithDefault<C, T extends AbiFunctionName<C>> = AbiFunction<
833 |   C,
834 |   T
835 | >['inputs'] extends readonly []
836 |   ? void | Record<string, never>
837 |   : AbiFunctionInputs<C, T>;
838 | 
839 | /**
840 |  * @category Models
841 |  */
842 | export type DecodedAbiFunctionInputs<C, T extends AbiFunctionName<C>> = MergeOutputObjectsArray<
843 |   AbiFunction<C, T>['inputs']
844 | >;
845 | /**
846 |  * @category Models
847 |  */
848 | export type DecodedAbiFunctionOutputs<C, T extends AbiFunctionName<C>> = MergeOutputObjectsArray<
849 |   AbiFunction<C, T>['outputs']
850 | >;
851 | 
852 | /**
853 |  * @category Models
854 |  */
855 | export type AbiGetterInputs<C, T extends AbiGetterName<C>> = MergeInputObjectsArray<AbiGetter<C, T>['inputs']>;
856 | 
857 | /**
858 |  * @category Models
859 |  */
860 | export type AbiGetterInputsWithDefault<C, T extends AbiGetterName<C>> = AbiGetter<
861 |   C,
862 |   T
863 | >['inputs'] extends readonly []
864 |   ? void | Record<string, never>
865 |   : AbiGetterInputs<C, T>;
866 | 
867 | /**
868 |  * @category Models
869 |  */
870 | export type DecodedAbiGetterInputs<C, T extends AbiGetterName<C>> = MergeOutputObjectsArray<
871 |   AbiGetter<C, T>['inputs']
872 | >;
873 | /**
874 |  * @category Models
875 |  */
876 | export type DecodedAbiGetterOutputs<C, T extends AbiGetterName<C>> = MergeOutputObjectsArray<
877 |   AbiGetter<C, T>['outputs']
878 | >;
879 | 
880 | /**
881 |  * @category Models
882 |  */
883 | export type DecodedAbiEventData<C, T extends AbiEventName<C>> = MergeOutputObjectsArray<AbiEvent<C, T>['inputs']>;
884 | 
885 | /**
886 |  * @category Models
887 |  */
888 | export type DecodedAbiInitData<C> = C extends { data: infer D } ? Partial<MergeOutputObjectsArray<D>> : never;
889 | 
890 | /**
891 |  * @category Models
892 |  */
893 | export type DecodedAbiFields<C> = C extends { fields: infer F } ? MergeOutputObjectsArray<F> : never;
894 | 


--------------------------------------------------------------------------------
/src/stream.ts:
--------------------------------------------------------------------------------
   1 | import { ProviderEvent, ProviderEventData } from './api';
   2 | import { Address, Semaphore, getUniqueId, LT_COLLATOR } from './utils';
   3 | import { TransactionId, Transaction, TransactionsBatchInfo, TransactionWithAccount, parseTransaction } from './models';
   4 | import { ProviderRpcClient, Subscription } from './index';
   5 | 
   6 | type SubscriptionWithAddress = Extract<ProviderEvent, 'transactionsFound' | 'contractStateChanged'>
   7 | 
   8 | type EventHandler<K extends SubscriptionWithAddress> = {
   9 |   onData: (event: ProviderEventData<K>) => Promise<boolean>,
  10 |   onEnd: (eof: boolean) => void,
  11 |   queue: PromiseQueue
  12 |   state: { eof: boolean, finished: boolean },
  13 | };
  14 | 
  15 | type SubscriptionsWithAddress = {
  16 |   [K in SubscriptionWithAddress]?: {
  17 |     subscription: Promise<Subscription<K>>
  18 |     handlers: Map<number, EventHandler<K>>
  19 |   }
  20 | };
  21 | 
  22 | /**
  23 |  * @category Stream
  24 |  */
  25 | export class Subscriber {
  26 |   private readonly subscriptions: Map<string, SubscriptionsWithAddress> = new Map();
  27 |   private readonly scanners: Map<number, Scanner> = new Map();
  28 | 
  29 |   constructor(private readonly provider: ProviderRpcClient) {
  30 |   }
  31 | 
  32 |   /**
  33 |    * Returns a stream of new transactions
  34 |    */
  35 |   public transactions(address: Address): IdentityStream<ProviderEventData<'transactionsFound'>> {
  36 |     return this._addSubscription('transactionsFound', address, false);
  37 |   }
  38 | 
  39 |   /**
  40 |    * Returns a finite stream of child transactions
  41 |    * @param transaction - root transaction
  42 |    */
  43 |   public trace(transaction: Transaction): IdentityStream<TransactionWithAccount, true> {
  44 |     const id = getUniqueId();
  45 | 
  46 |     return new StreamImpl(
  47 |       (onData, onEnd) => {
  48 |         const scanner = new TraceTransactionsScanner(this.provider, {
  49 |           origin: transaction,
  50 |           onData,
  51 |           onEnd: (eof) => {
  52 |             this.scanners.delete(id);
  53 |             onEnd(eof);
  54 |           },
  55 |         });
  56 |         this.scanners.set(id, scanner);
  57 |         scanner.start();
  58 | 
  59 |         // Subscription is not required
  60 |         return Promise.resolve();
  61 |       },
  62 |       async () => {
  63 |         const scanner = this.scanners.get(id);
  64 |         if (scanner != null) {
  65 |           this.scanners.delete(id);
  66 |           await scanner.stop();
  67 |         }
  68 |       },
  69 |       identity,
  70 |       true,
  71 |     );
  72 |   }
  73 | 
  74 |   /**
  75 |    * Returns a stream of old transactions
  76 |    */
  77 |   public oldTransactions(
  78 |     address: Address,
  79 |     filter?: { fromLt?: string, fromUtime?: number },
  80 |   ): IdentityStream<ProviderEventData<'transactionsFound'>, true> {
  81 |     const id = getUniqueId();
  82 | 
  83 |     return new StreamImpl(
  84 |       (onData, onEnd) => {
  85 |         const scanner = new UnorderedTransactionsScanner(this.provider, {
  86 |           address,
  87 |           onData,
  88 |           onEnd: (eof) => {
  89 |             this.scanners.delete(id);
  90 |             onEnd(eof);
  91 |           },
  92 |           ...filter,
  93 |         });
  94 |         this.scanners.set(id, scanner);
  95 |         scanner.start();
  96 | 
  97 |         // Subscription is not required
  98 |         return Promise.resolve();
  99 |       },
 100 |       async () => {
 101 |         const scanner = this.scanners.get(id);
 102 |         if (scanner != null) {
 103 |           this.scanners.delete(id);
 104 |           await scanner.stop();
 105 |         }
 106 |       },
 107 |       identity,
 108 |       true,
 109 |     );
 110 |   }
 111 | 
 112 |   public states(address: Address): IdentityStream<ProviderEventData<'contractStateChanged'>> {
 113 |     return this._addSubscription('contractStateChanged', address, false);
 114 |   }
 115 | 
 116 |   public unsubscribe = async (): Promise<void> => this._unsubscribe();
 117 | 
 118 |   private async _unsubscribe(): Promise<void> {
 119 |     const tasks: Promise<void>[] = [];
 120 | 
 121 |     for (const item of this.subscriptions.values()) {
 122 |       for (const [event, eventData] of Object.entries(item)) {
 123 |         delete item[event as unknown as SubscriptionWithAddress];
 124 |         if (eventData != null) {
 125 |           tasks.push(
 126 |             eventData.subscription
 127 |               .then(item => item.unsubscribe())
 128 |               .catch(() => { /* ignore */
 129 |               }),
 130 |           );
 131 |         }
 132 |       }
 133 |     }
 134 |     this.subscriptions.clear();
 135 | 
 136 |     for (const scanner of this.scanners.values()) {
 137 |       tasks.push(scanner.stop());
 138 |     }
 139 |     this.scanners.clear();
 140 | 
 141 |     await Promise.all(tasks);
 142 |   }
 143 | 
 144 |   private _addSubscription<T extends keyof SubscriptionsWithAddress, F extends boolean>(
 145 |     event: T,
 146 |     address: Address,
 147 |     isFinite: F,
 148 |   ): IdentityStream<ProviderEventData<T>, F> {
 149 |     type EventData = Exclude<SubscriptionsWithAddress[T], undefined>;
 150 | 
 151 |     const rawAddress = address.toString();
 152 | 
 153 |     const stopProducer = (id: number) => {
 154 |       const subscriptions = this.subscriptions.get(rawAddress);
 155 |       if (subscriptions == null) {
 156 |         // No subscriptions for the address
 157 |         return;
 158 |       }
 159 | 
 160 |       const eventData = subscriptions[event] as EventData | undefined;
 161 |       if (eventData != null) {
 162 |         const handler = eventData.handlers.get(id);
 163 |         if (handler != null) {
 164 |           // Remove event handler with the id
 165 |           eventData.handlers.delete(id);
 166 | 
 167 |           const { queue, onEnd, state } = handler;
 168 |           if (!state.finished) {
 169 |             state.finished = true;
 170 |             queue.clear();
 171 |             queue.enqueue(async () => onEnd(state.eof));
 172 |           }
 173 |         }
 174 | 
 175 |         // Remove event data subscription if there are none of them
 176 |         if (eventData.handlers.size === 0) {
 177 |           const subscription = eventData.subscription as Promise<Subscription<T>>;
 178 |           delete subscriptions[event];
 179 | 
 180 |           subscription
 181 |             .then((subscription) => subscription.unsubscribe())
 182 |             .catch(console.debug);
 183 |         }
 184 |       }
 185 | 
 186 |       // Remove address subscriptions object if it is empty
 187 |       if (subscriptions.contractStateChanged == null && subscriptions.transactionsFound == null) {
 188 |         this.subscriptions.delete(rawAddress);
 189 |       }
 190 |     };
 191 | 
 192 |     const id = getUniqueId();
 193 | 
 194 |     return new StreamImpl(
 195 |       (onData, onEnd) => {
 196 |         const subscriptions = this.subscriptions.get(rawAddress);
 197 |         let eventData = subscriptions?.[event] as EventData | undefined;
 198 | 
 199 |         const state = { eof: false, finished: false };
 200 | 
 201 |         // Create handler object
 202 |         const handler: EventHandler<T> = {
 203 |           onData,
 204 |           onEnd,
 205 |           queue: new PromiseQueue(),
 206 |           state,
 207 |         };
 208 | 
 209 |         if (eventData != null) {
 210 |           // Add handler if there is already a handler group
 211 |           eventData.handlers.set(id, handler);
 212 |           return Promise.resolve();
 213 |         }
 214 | 
 215 |         // Create handlers group
 216 |         const handlers: EventData['handlers'] = new Map();
 217 |         handlers.set(id, handler);
 218 | 
 219 |         type ProviderMethod = (eventName: T, params: { address: Address }) => Promise<Subscription<T>>;
 220 | 
 221 |         // Create subscription
 222 |         const subscription = (this.provider.subscribe as unknown as ProviderMethod)(event, { address })
 223 |           .then((subscription: Subscription<T>) => {
 224 |             subscription.on('data', (data) => {
 225 |               for (const { onData, queue, state } of handlers.values()) {
 226 |                 // Skip closed streams
 227 |                 if (state.eof || state.finished) {
 228 |                   continue;
 229 |                 }
 230 | 
 231 |                 queue.enqueue(async () => {
 232 |                   if (!(await onData(data))) {
 233 |                     state.eof = true;
 234 |                     stopProducer(id);
 235 |                   }
 236 |                 });
 237 |               }
 238 |             });
 239 |             subscription.on('unsubscribed', () => {
 240 |               for (const id of handlers.keys()) {
 241 |                 stopProducer(id);
 242 |               }
 243 |             });
 244 |             return subscription;
 245 |           }).catch((e: Error) => {
 246 |             console.error(e);
 247 |             for (const id of handlers.keys()) {
 248 |               stopProducer(id);
 249 |             }
 250 |             throw e;
 251 |           });
 252 | 
 253 |         // Add event data to subscriptions
 254 |         eventData = { subscription, handlers } as EventData;
 255 |         if (subscriptions == null) {
 256 |           this.subscriptions.set(rawAddress, { [event]: eventData });
 257 |         } else {
 258 |           subscriptions[event] = eventData;
 259 |         }
 260 | 
 261 |         // Wait until subscribed
 262 |         return subscription.then(() => { /* do nothing */
 263 |         });
 264 |       },
 265 |       () => stopProducer(id),
 266 |       identity,
 267 |       isFinite,
 268 |     );
 269 |   }
 270 | }
 271 | 
 272 | interface Scanner {
 273 |   stop(): Promise<void>;
 274 | }
 275 | 
 276 | async function identity<P>(item: P, handler: (item: P) => (Promise<boolean> | boolean)) {
 277 |   return handler(item);
 278 | }
 279 | 
 280 | /**
 281 |  * @category Stream
 282 |  */
 283 | export type BothFinite<F extends boolean, F1 extends boolean> =
 284 |   F extends true ? F1 extends true ? true : false : false;
 285 | 
 286 | /**
 287 |  * @category Stream
 288 |  */
 289 | export type IdentityStream<T, F extends boolean = false> = Stream<T, T, F>;
 290 | 
 291 | /**
 292 |  * @category Stream
 293 |  */
 294 | export interface Stream<P, T, F extends boolean = false> {
 295 |   readonly makeProducer: (onData: (data: P) => Promise<boolean>, onEnd: (eof: boolean) => void) => Promise<void>;
 296 |   readonly stopProducer: () => void;
 297 |   readonly isFinite: F;
 298 | 
 299 |   /**
 300 |    * Waits until contract subscription is ready and then returns a promise with the result
 301 |    */
 302 |   delayed<R>(f: (stream: Delayed<P, T, F>) => DelayedPromise<R>): Promise<() => R>;
 303 | 
 304 |   /**
 305 |    * Waits for the first element or the end of the stream
 306 |    */
 307 |   first(): Promise<F extends true ? T | undefined : T>;
 308 | 
 309 |   /**
 310 |    * Folds every element into an accumulator by applying an operation, returning the final result
 311 |    */
 312 |   fold: F extends true ? <B>(init: B, f: (init: B, item: T) => (Promise<B> | B)) => Promise<B> : never;
 313 | 
 314 |   /**
 315 |    * Waits until the end of the stream
 316 |    */
 317 |   finished: F extends true ? () => Promise<void> : never;
 318 | 
 319 |   /**
 320 |    * Executes handler on each item
 321 |    */
 322 |   on(handler: (item: T) => (Promise<void> | void)): void;
 323 | 
 324 |   /**
 325 |    * Merges two streams
 326 |    */
 327 |   merge<F1 extends boolean>(other: Stream<P, T, F1>): Stream<P, T, BothFinite<F, F1>>;
 328 | 
 329 |   /**
 330 |    * Creates a stream which gives the current iteration count as well as the value
 331 |    */
 332 |   enumerate(): Stream<P, { index: number, item: T }, F>;
 333 | 
 334 |   /**
 335 |    * Alias for the `.map((item) => { f(item); return item; })`
 336 |    */
 337 |   tap(handler: (item: T) => (Promise<void> | void)): Stream<P, T, F>;
 338 | 
 339 |   /**
 340 |    * Skip elements where `f(item) == false`
 341 |    */
 342 |   filter(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, F>;
 343 | 
 344 |   /**
 345 |    * Modifies items and skip all `undefined`
 346 |    */
 347 |   filterMap<U>(f: (item: T) => (Promise<(U | undefined)> | (U | undefined))): Stream<P, U, F>;
 348 | 
 349 |   /**
 350 |    * Modifies items
 351 |    */
 352 |   map<U>(f: (item: T) => (Promise<U> | U)): Stream<P, U, F>;
 353 | 
 354 |   /**
 355 |    * Creates an iterator that flattens nested structure
 356 |    */
 357 |   flatMap<U>(f: (item: T) => (Promise<U[]> | U[])): Stream<P, U, F>;
 358 | 
 359 |   /**
 360 |    * Creates an iterator that skips the first n elements
 361 |    */
 362 |   skip(n: number): Stream<P, T, F>;
 363 | 
 364 |   /**
 365 |    * Creates an iterator that skips elements based on a predicate
 366 |    */
 367 |   skipWhile(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, F>;
 368 | 
 369 |   /**
 370 |    * Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner
 371 |    */
 372 |   take(n: number): Stream<P, T, true>;
 373 | 
 374 |   /**
 375 |    * Creates an iterator that yields elements based on a predicate
 376 |    */
 377 |   takeWhile(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, true>;
 378 | 
 379 |   /**
 380 |    * Creates an iterator that yields mapped elements based on a predicate until first `undefined` is found
 381 |    */
 382 |   takeWhileMap<U>(f: (item: T) => (Promise<(U | undefined)> | (U | undefined))): Stream<P, U, true>;
 383 | }
 384 | 
 385 | /**
 386 |  * @category Stream
 387 |  */
 388 | export type Delayed<P, T, F extends boolean> = {
 389 |   first: MakeDelayedPromise<Stream<P, T, F>['first']>,
 390 |   on: MakeDelayedPromise<Stream<P, T, F>['on']>,
 391 | } & (F extends true ? {
 392 |   fold: MakeDelayedPromise<Stream<P, T, F>['fold']>,
 393 |   finished: MakeDelayedPromise<Stream<P, T, F>['finished']>,
 394 | } : {});
 395 | 
 396 | /**
 397 |  * @category Stream
 398 |  */
 399 | export type MakeDelayedPromise<F> = F extends (...args: infer Args) => infer R
 400 |   ? (...args: Args) => DelayedPromise<R>
 401 |   : never;
 402 | 
 403 | /**
 404 |  * @category Stream
 405 |  */
 406 | export type DelayedPromise<T> = { subscribed: Promise<void>, result: T };
 407 | 
 408 | class StreamImpl<P, T, F extends boolean> implements Stream<P, T, F> {
 409 |   constructor(
 410 |     readonly makeProducer: (onData: (data: P) => Promise<boolean>, onEnd: (eof: boolean) => void) => Promise<void>,
 411 |     readonly stopProducer: () => void,
 412 |     readonly extractor: (data: P, handler: (item: T) => (Promise<boolean> | boolean)) => Promise<boolean>,
 413 |     readonly isFinite: F,
 414 |   ) {
 415 |   }
 416 | 
 417 |   public async delayed<R>(f: (stream: Delayed<P, T, F>) => DelayedPromise<R>): Promise<() => R> {
 418 |     const { subscribed, result } = f({
 419 |       first: (() => {
 420 |         const ctx: { subscribed?: Promise<void> } = {};
 421 |         const result = this.first(ctx);
 422 |         return { subscribed: ctx.subscribed!, result };
 423 |       }),
 424 |       on: (handler: (item: T) => (Promise<void> | void)): DelayedPromise<void> => {
 425 |         const ctx: { subscribed?: Promise<void> } = {};
 426 |         this.on(handler, ctx);
 427 |         return { subscribed: ctx.subscribed!, result: undefined };
 428 |       },
 429 |       fold: this.fold != null ? <B>(init: B, f: (init: B, item: T) => (Promise<B> | B)): DelayedPromise<Promise<B>> => {
 430 |         const ctx: { subscribed?: Promise<void> } = {};
 431 |         const result = this.fold(init, f, ctx);
 432 |         return { subscribed: ctx.subscribed!, result };
 433 |       } : undefined as never,
 434 |       finished: this.finished != null ? (): DelayedPromise<Promise<void>> => {
 435 |         const ctx: { subscribed?: Promise<void> } = {};
 436 |         const result = this.finished(ctx);
 437 |         return { subscribed: ctx.subscribed!, result };
 438 |       } : undefined as never,
 439 |     } as unknown as Delayed<P, T, F>);
 440 |     await subscribed;
 441 |     return () => result;
 442 |   }
 443 | 
 444 |   public first(ctx?: { subscribed?: Promise<void> }): Promise<F extends true ? T | undefined : T> {
 445 |     type R = F extends true ? T | undefined : T;
 446 | 
 447 |     const state: { found: boolean, result?: T } = { found: false };
 448 | 
 449 |     return new Promise<R>((resolve: (value: R) => void, reject) => {
 450 |       const subscribed = this.makeProducer(
 451 |         // onData
 452 |         (data) => this.extractor(data, (item) => {
 453 |           Object.assign(state, { found: true, result: item });
 454 |           return false;
 455 |         }),
 456 |         // onEnd
 457 |         (eof) => {
 458 |           if (eof) {
 459 |             if (this.isFinite) {
 460 |               resolve((state.found ? state.result : undefined) as R);
 461 |             } else if (state.found) {
 462 |               resolve(state.result as R);
 463 |             } else {
 464 |               reject(new Error('Unexpected end of stream'));
 465 |             }
 466 |           } else {
 467 |             reject(new Error('Subscription closed'));
 468 |           }
 469 |         },
 470 |       );
 471 | 
 472 |       if (ctx != null) {
 473 |         ctx.subscribed = subscribed;
 474 |       }
 475 |     });
 476 |   }
 477 | 
 478 |   /**
 479 |    * Folds every element into an accumulator by applying an operation, returning the final result
 480 |    */
 481 |   public fold = this.onlyFinite(<B>(init: B, f: (init: B, item: T) => (Promise<B> | B), ctx?: { subscribed?: Promise<void> }): Promise<B> => {
 482 |     let state = init;
 483 | 
 484 |     return new Promise<B>((resolve: (value: B) => void, reject) => {
 485 |       const subscribed = this.makeProducer(
 486 |         // onData
 487 |         (data) => this.extractor(data, async (item) => {
 488 |           state = await f(state, item);
 489 |           return true;
 490 |         }),
 491 |         // onEnd
 492 |         (eof) => {
 493 |           if (eof) {
 494 |             resolve(state);
 495 |           } else {
 496 |             reject(new Error('Subscription closed'));
 497 |           }
 498 |         },
 499 |       );
 500 | 
 501 |       if (ctx != null) {
 502 |         ctx.subscribed = subscribed;
 503 |       }
 504 |     });
 505 |   });
 506 | 
 507 |   /**
 508 |    * Waits until the end of the stream
 509 |    */
 510 |   public finished = this.onlyFinite((ctx?: { subscribed?: Promise<void> }): Promise<void> => {
 511 |     return new Promise<void>((resolve, reject) => {
 512 |       const subscribed = this.makeProducer(
 513 |         // onData
 514 |         (data) => this.extractor(data, (_item) => true),
 515 |         // onEnd
 516 |         (eof) => {
 517 |           if (eof) {
 518 |             resolve(undefined);
 519 |           } else {
 520 |             reject(new Error('Subscription closed'));
 521 |           }
 522 |         },
 523 |       );
 524 | 
 525 |       if (ctx != null) {
 526 |         ctx.subscribed = subscribed;
 527 |       }
 528 |     });
 529 |   });
 530 | 
 531 |   public on(handler: (item: T) => (Promise<void> | void), ctx?: { subscribed?: Promise<void> }): void {
 532 |     const subscribed = this.makeProducer(
 533 |       (event) => this.extractor(event, async (item) => {
 534 |         await handler(item);
 535 |         return true;
 536 |       }),
 537 |       (_eof) => { /* do nothing */
 538 |       },
 539 |     );
 540 | 
 541 |     if (ctx != null) {
 542 |       ctx.subscribed = subscribed;
 543 |     }
 544 |   }
 545 | 
 546 |   public merge<F1 extends boolean>(other: Stream<P, T, F1>): Stream<P, T, BothFinite<F, F1>> {
 547 |     return new StreamImpl<P, T, BothFinite<F, F1>>(
 548 |       (onData, onEnd) => {
 549 |         const state = {
 550 |           stopped: false,
 551 |           counter: 0,
 552 |         };
 553 |         const checkEnd = (eof: boolean) => {
 554 |           if (state.stopped) {
 555 |             return;
 556 |           }
 557 | 
 558 |           if (++state.counter == 2 || !eof) {
 559 |             state.stopped = true;
 560 |             onEnd(eof);
 561 |           }
 562 |         };
 563 | 
 564 |         return Promise.all([
 565 |           this.makeProducer(onData, checkEnd),
 566 |           other.makeProducer(onData, checkEnd),
 567 |         ]).then(() => { /* do nothing */
 568 |         });
 569 |       },
 570 |       () => {
 571 |         this.stopProducer();
 572 |         other.stopProducer();
 573 |       },
 574 |       this.extractor,
 575 |       (this.isFinite && other.isFinite) as BothFinite<F, F1>,
 576 |     );
 577 |   }
 578 | 
 579 |   public enumerate(): Stream<P, { index: number, item: T }, F> {
 580 |     const state = {
 581 |       index: 0,
 582 |     };
 583 | 
 584 |     return new StreamImpl(
 585 |       this.makeProducer,
 586 |       this.stopProducer,
 587 |       (event, handler) =>
 588 |         this.extractor(event, async (item: T) => {
 589 |           return handler({
 590 |             index: state.index++,
 591 |             item,
 592 |           });
 593 |         }),
 594 |       this.isFinite,
 595 |     );
 596 |   }
 597 | 
 598 |   public tap(f: (item: T) => (Promise<void> | void)): Stream<P, T, F> {
 599 |     return new StreamImpl<P, T, F>(
 600 |       this.makeProducer,
 601 |       this.stopProducer,
 602 |       (event, handler) =>
 603 |         this.extractor(event, async (item: T) => {
 604 |           await f(item);
 605 |           return handler(item);
 606 |         }),
 607 |       this.isFinite,
 608 |     );
 609 |   }
 610 | 
 611 |   public filter(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, F> {
 612 |     return new StreamImpl(
 613 |       this.makeProducer,
 614 |       this.stopProducer,
 615 |       (event, handler) =>
 616 |         this.extractor(event, async (item) => {
 617 |           if (await f(item)) {
 618 |             return handler(item);
 619 |           } else {
 620 |             return true;
 621 |           }
 622 |         }),
 623 |       this.isFinite,
 624 |     );
 625 |   }
 626 | 
 627 |   public filterMap<U>(f: (item: T) => (Promise<(U | undefined)> | (U | undefined))): Stream<P, U, F> {
 628 |     return new StreamImpl(
 629 |       this.makeProducer,
 630 |       this.stopProducer,
 631 |       (event, handler) =>
 632 |         this.extractor(event, async (item: T) => {
 633 |           const newItem = await f(item);
 634 |           if (newItem !== undefined) {
 635 |             return handler(newItem);
 636 |           } else {
 637 |             return true;
 638 |           }
 639 |         }),
 640 |       this.isFinite,
 641 |     );
 642 |   }
 643 | 
 644 |   public map<U>(f: (item: T) => (Promise<U> | U)): Stream<P, U, F> {
 645 |     return new StreamImpl(
 646 |       this.makeProducer,
 647 |       this.stopProducer,
 648 |       (event, handler) =>
 649 |         this.extractor(event, async (item: T) => {
 650 |           const newItem = await f(item);
 651 |           return handler(newItem);
 652 |         }),
 653 |       this.isFinite,
 654 |     );
 655 |   }
 656 | 
 657 |   public flatMap<U>(f: (item: T) => (Promise<U[]> | U[])): Stream<P, U, F> {
 658 |     return new StreamImpl(
 659 |       this.makeProducer,
 660 |       this.stopProducer,
 661 |       (event, handler) =>
 662 |         this.extractor(event, async (item: T) => {
 663 |           const items = await f(item);
 664 |           for (const newItem of items) {
 665 |             if (!(await handler(newItem))) {
 666 |               return false;
 667 |             }
 668 |           }
 669 |           return true;
 670 |         }),
 671 |       this.isFinite,
 672 |     );
 673 |   }
 674 | 
 675 |   public skip(n: number): Stream<P, T, F> {
 676 |     const state = {
 677 |       index: 0,
 678 |     };
 679 | 
 680 |     return new StreamImpl(
 681 |       this.makeProducer,
 682 |       this.stopProducer,
 683 |       (event, handler) =>
 684 |         this.extractor(event, (item) => {
 685 |           if (state.index >= n) {
 686 |             return handler(item);
 687 |           } else {
 688 |             ++state.index;
 689 |             return true;
 690 |           }
 691 |         }),
 692 |       this.isFinite,
 693 |     );
 694 |   }
 695 | 
 696 |   public skipWhile(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, F> {
 697 |     const state = {
 698 |       shouldSkip: true,
 699 |     };
 700 | 
 701 |     return new StreamImpl(
 702 |       this.makeProducer,
 703 |       this.stopProducer,
 704 |       (event, handler) =>
 705 |         this.extractor(event, async (item) => {
 706 |           if (!state.shouldSkip || !(await f(item))) {
 707 |             state.shouldSkip = false;
 708 |             return handler(item);
 709 |           } else {
 710 |             return true;
 711 |           }
 712 |         }),
 713 |       this.isFinite,
 714 |     );
 715 |   }
 716 | 
 717 |   public take(n: number): Stream<P, T, true> {
 718 |     const state = {
 719 |       index: 0,
 720 |     };
 721 | 
 722 |     return new StreamImpl(
 723 |       this.makeProducer,
 724 |       this.stopProducer,
 725 |       (event, handler) =>
 726 |         this.extractor(event, (item) => {
 727 |           if (state.index < n) {
 728 |             ++state.index;
 729 |             // NOTE: Execute the handler and ensure that `false` is returned right after the Nth call
 730 |             return handler(item) && state.index < n;
 731 |           } else {
 732 |             return false;
 733 |           }
 734 |         }),
 735 |       true,
 736 |     );
 737 |   }
 738 | 
 739 |   public takeWhile(f: (item: T) => (Promise<boolean> | boolean)): Stream<P, T, true> {
 740 |     return new StreamImpl(
 741 |       this.makeProducer,
 742 |       this.stopProducer,
 743 |       (event, handler) =>
 744 |         this.extractor(event, async (item) => {
 745 |           if (await f(item)) {
 746 |             return handler(item);
 747 |           } else {
 748 |             return false;
 749 |           }
 750 |         }),
 751 |       true,
 752 |     );
 753 |   }
 754 | 
 755 |   public takeWhileMap<U>(f: (item: T) => (Promise<(U | undefined)> | (U | undefined))): Stream<P, U, true> {
 756 |     return new StreamImpl(
 757 |       this.makeProducer,
 758 |       this.stopProducer,
 759 |       (event, handler) =>
 760 |         this.extractor(event, async (item: T) => {
 761 |           const newItem = await f(item);
 762 |           if (newItem !== undefined) {
 763 |             return handler(newItem);
 764 |           } else {
 765 |             return false;
 766 |           }
 767 |         }),
 768 |       true,
 769 |     );
 770 |   }
 771 | 
 772 |   public onlyFinite<C>(f: C): F extends true ? C : never {
 773 |     if (this.isFinite) {
 774 |       return f as any;
 775 |     } else {
 776 |       return undefined as never;
 777 |     }
 778 |   }
 779 | }
 780 | 
 781 | type UnorderedTransactionsScannerParams = {
 782 |   address: Address;
 783 |   onData: (data: ProviderEventData<'transactionsFound'>) => Promise<boolean>;
 784 |   onEnd: (eof: boolean) => void;
 785 |   fromLt?: string;
 786 |   fromUtime?: number;
 787 | };
 788 | 
 789 | class UnorderedTransactionsScanner implements Scanner {
 790 |   private readonly queue: PromiseQueue = new PromiseQueue();
 791 | 
 792 |   private continuation?: TransactionId;
 793 |   private promise?: Promise<void>;
 794 |   private isRunning = false;
 795 | 
 796 |   constructor(
 797 |     private readonly provider: ProviderRpcClient,
 798 |     private readonly params: UnorderedTransactionsScannerParams,
 799 |   ) {
 800 |   }
 801 | 
 802 |   public start() {
 803 |     if (this.isRunning || this.promise != null) {
 804 |       return;
 805 |     }
 806 | 
 807 |     this.isRunning = true;
 808 |     this.promise = (async () => {
 809 |       const params = this.params;
 810 |       const state = {
 811 |         complete: false,
 812 |       };
 813 | 
 814 |       while (this.isRunning && !state.complete) {
 815 |         try {
 816 |           const { transactions, continuation } = await this.provider.getTransactions({
 817 |             address: this.params.address,
 818 |             continuation: this.continuation,
 819 |           });
 820 | 
 821 |           state.complete = !state.complete && transactions.length == null;
 822 |           if (!this.isRunning || state.complete) {
 823 |             break;
 824 |           }
 825 | 
 826 |           const filteredTransactions = transactions.filter((item) => (
 827 |             (params.fromLt == null || LT_COLLATOR.compare(item.id.lt, params.fromLt) > 0) &&
 828 |             (params.fromUtime == null || item.createdAt > params.fromUtime)
 829 |           ));
 830 | 
 831 |           if (filteredTransactions.length == 0) {
 832 |             state.complete = true;
 833 |             break;
 834 |           }
 835 | 
 836 |           const info = {
 837 |             maxLt: filteredTransactions[0].id.lt,
 838 |             minLt: filteredTransactions[filteredTransactions.length - 1].id.lt,
 839 |             batchType: 'old',
 840 |           } as TransactionsBatchInfo;
 841 | 
 842 |           this.queue.enqueue(async () => {
 843 |             const isRunning = await this.params.onData({
 844 |               address: this.params.address,
 845 |               transactions: filteredTransactions,
 846 |               info,
 847 |             });
 848 |             if (!isRunning) {
 849 |               state.complete = true;
 850 |               this.isRunning = false;
 851 |             }
 852 |           });
 853 | 
 854 |           if (continuation != null) {
 855 |             this.continuation = continuation;
 856 |           } else {
 857 |             state.complete = true;
 858 |             break;
 859 |           }
 860 |         } catch (e) {
 861 |           console.error(e);
 862 |         }
 863 |       }
 864 | 
 865 |       this.queue.enqueue(async () => this.params.onEnd(state.complete));
 866 |       this.isRunning = false;
 867 |       this.continuation = undefined;
 868 |     })();
 869 |   }
 870 | 
 871 |   public async stop() {
 872 |     this.isRunning = false;
 873 |     this.queue.clear();
 874 |     if (this.promise != null) {
 875 |       await this.promise;
 876 |     } else {
 877 |       this.params.onEnd(false);
 878 |     }
 879 |   }
 880 | }
 881 | 
 882 | type TraceTransactionsScannerParams = {
 883 |   origin: Transaction,
 884 |   onData: (data: TransactionWithAccount) => Promise<boolean>;
 885 |   onEnd: (eof: boolean) => void;
 886 | };
 887 | 
 888 | type PendingTransaction = {
 889 |   promise: Promise<TransactionWithAccount | undefined>;
 890 |   reject: () => void;
 891 | }
 892 | 
 893 | class TraceTransactionsScanner implements Scanner {
 894 |   private readonly queue: PromiseQueue = new PromiseQueue();
 895 | 
 896 |   private promise?: Promise<void>;
 897 |   private isRunning = false;
 898 |   private pendingTransactions?: PendingTransaction[];
 899 |   private semaphore = new Semaphore(10);
 900 | 
 901 |   constructor(
 902 |     private readonly provider: ProviderRpcClient,
 903 |     private readonly params: TraceTransactionsScannerParams,
 904 |   ) {
 905 |   }
 906 | 
 907 |   public start() {
 908 |     if (this.isRunning || this.promise != null) {
 909 |       return;
 910 |     }
 911 | 
 912 |     const provider = this.provider;
 913 | 
 914 |     this.isRunning = true;
 915 |     this.promise = (async () => {
 916 |       const state = {
 917 |         complete: false,
 918 |       };
 919 | 
 920 |       const makePendingTransaction = (messageHash: string): PendingTransaction => {
 921 |         const state: { stopped: boolean, reject?: () => void, timeout?: number } = { stopped: false };
 922 | 
 923 |         const promise = (async () => {
 924 |           let timeout = 500;
 925 | 
 926 |           while (true) {
 927 |             const release = await this.semaphore.acquire();
 928 |             if (state.stopped) {
 929 |               release();
 930 |               return;
 931 |             }
 932 |             const result = await provider.rawApi.findTransaction({
 933 |               inMessageHash: messageHash,
 934 |             }).catch(() => ({ transaction: undefined })).finally(() => release());
 935 |             if (state.stopped) {
 936 |               return;
 937 |             }
 938 | 
 939 |             if (result.transaction != null) {
 940 |               const transaction = parseTransaction(result.transaction);
 941 |               (transaction as TransactionWithAccount).account = transaction.inMessage.dst!;
 942 |               return (transaction as TransactionWithAccount);
 943 |             }
 944 | 
 945 |             let resolve: () => void;
 946 |             const promise = new Promise<void>((resolvePromise, rejectPromise) => {
 947 |               resolve = () => resolvePromise();
 948 |               state.reject = () => rejectPromise();
 949 |             });
 950 |             state.timeout = setTimeout(resolve!, timeout);
 951 |             await promise;
 952 |             if (state.stopped) {
 953 |               return;
 954 |             }
 955 | 
 956 |             state.reject = undefined;
 957 |             timeout = Math.min(timeout * 2, 3000);
 958 |           }
 959 |         })();
 960 | 
 961 |         const reject = () => {
 962 |           state.stopped = true;
 963 |           state.reject?.();
 964 |           if (state.timeout != null) {
 965 |             clearTimeout(state.timeout);
 966 |           }
 967 |         };
 968 | 
 969 |         return { promise, reject };
 970 |       };
 971 | 
 972 |       const transactionsQueue = [this.params.origin];
 973 |       try {
 974 |         outer: while (this.isRunning) {
 975 |           const transaction = transactionsQueue.shift();
 976 |           if (transaction == null) {
 977 |             state.complete = true;
 978 |             break;
 979 |           }
 980 | 
 981 |           // Spawn promises
 982 |           const pendingTransactions = transaction
 983 |             .outMessages
 984 |             .filter((message) => message.dst != null)
 985 |             .map((message) => {
 986 |               const messageHash = message.hash;
 987 |               return makePendingTransaction(messageHash);
 988 |             });
 989 |           this.pendingTransactions = pendingTransactions;
 990 | 
 991 |           for (const { promise } of pendingTransactions) {
 992 |             const childTransaction = await promise;
 993 |             if (!this.isRunning || state.complete || childTransaction == null) {
 994 |               break outer;
 995 |             }
 996 | 
 997 |             this.queue.enqueue(async () => {
 998 |               const isRunning = await this.params.onData(childTransaction);
 999 |               if (!isRunning) {
1000 |                 state.complete = true;
1001 |                 this.isRunning = false;
1002 |                 this.rejectPendingTransactions();
1003 |               }
1004 |             });
1005 | 
1006 |             transactionsQueue.push(childTransaction);
1007 |           }
1008 | 
1009 |           this.pendingTransactions = undefined;
1010 |         }
1011 |       } catch (e: unknown) {
1012 |         console.error(e);
1013 |         /* do nothing */
1014 |       } finally {
1015 |         this.queue.enqueue(async () => this.params.onEnd(state.complete));
1016 |         this.isRunning = false;
1017 |         this.rejectPendingTransactions();
1018 |       }
1019 |     })();
1020 |   }
1021 | 
1022 |   public async stop() {
1023 |     this.isRunning = false;
1024 |     this.queue.clear();
1025 | 
1026 |     this.rejectPendingTransactions();
1027 | 
1028 |     if (this.promise != null) {
1029 |       await this.promise;
1030 |     } else {
1031 |       this.params.onEnd(false);
1032 |     }
1033 |   }
1034 | 
1035 |   private rejectPendingTransactions() {
1036 |     if (this.pendingTransactions != null) {
1037 |       for (const pendingTransaction of this.pendingTransactions) {
1038 |         pendingTransaction.reject();
1039 |       }
1040 |       this.pendingTransactions = undefined;
1041 |     }
1042 |     this.semaphore.releaseAll();
1043 |   }
1044 | }
1045 | 
1046 | class PromiseQueue {
1047 |   private readonly queue: (() => Promise<void>)[] = [];
1048 |   private workingOnPromise = false;
1049 | 
1050 |   public enqueue(promise: () => Promise<void>) {
1051 |     this.queue.push(promise);
1052 |     this._dequeue().catch(() => { /* do nothing */
1053 |     });
1054 |   }
1055 | 
1056 |   public clear() {
1057 |     this.queue.length = 0;
1058 |   }
1059 | 
1060 |   private async _dequeue() {
1061 |     if (this.workingOnPromise) {
1062 |       return;
1063 |     }
1064 | 
1065 |     const item = this.queue.shift();
1066 |     if (!item) {
1067 |       return;
1068 |     }
1069 | 
1070 |     this.workingOnPromise = true;
1071 |     item()
1072 |       .then(() => {
1073 |         this.workingOnPromise = false;
1074 |         this._dequeue();
1075 |       })
1076 |       .catch(() => {
1077 |         this.workingOnPromise = false;
1078 |         this._dequeue();
1079 |       });
1080 |   }
1081 | }
1082 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
   1 | import {
   2 |   ProviderApiRequestParams,
   3 |   ProviderApiResponse,
   4 |   ProviderEvent,
   5 |   ProviderEventData,
   6 |   ProviderMethod,
   7 |   RawProviderApiRequestParams,
   8 |   RawProviderApiResponse,
   9 |   RawProviderEventData,
  10 |   RawProviderRequest,
  11 | } from './api';
  12 | 
  13 | import {
  14 |   AbiVersion,
  15 |   AbiParam,
  16 |   AssetType,
  17 |   AssetTypeParams,
  18 |   ContractUpdatesSubscription,
  19 |   EncryptedData,
  20 |   DecodedAbiInitData,
  21 |   MergeInputObjectsArray,
  22 |   MergeOutputObjectsArray,
  23 |   ReadonlyAbiParam,
  24 |   parsePermissions,
  25 |   parseTokensObject,
  26 |   parsePartialTokensObject,
  27 |   parseTransaction,
  28 |   serializeTokensObject,
  29 |   serializeIgnoreCode,
  30 | } from './models';
  31 | import { Address, DelayedTransactions, getUniqueId } from './utils';
  32 | import * as subscriber from './stream';
  33 | import * as contract from './contract';
  34 | import { EverscaleProviderAdapter, isProviderAdapter, ProviderAdapter, StaticProviderAdapter } from './adapters';
  35 | 
  36 | export * from './adapters';
  37 | export * from './api';
  38 | export * from './models';
  39 | export * from './contract';
  40 | export { Stream, Subscriber } from './stream';
  41 | export {
  42 |   Address,
  43 |   CheckAddress,
  44 |   AddressLiteral,
  45 |   UniqueArray,
  46 |   MessageExpiredException,
  47 |   mergeTransactions,
  48 |   isAddressObject,
  49 |   LT_COLLATOR,
  50 | } from './utils';
  51 | 
  52 | /**
  53 |  * @category Provider
  54 |  */
  55 | export interface Provider {
  56 |   request<T extends ProviderMethod>(data: RawProviderRequest<T>): Promise<RawProviderApiResponse<T>>;
  57 | 
  58 |   addListener<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  59 | 
  60 |   removeListener<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  61 | 
  62 |   on<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  63 | 
  64 |   once<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  65 | 
  66 |   prependListener<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  67 | 
  68 |   prependOnceListener<T extends ProviderEvent>(eventName: T, listener: (data: RawProviderEventData<T>) => void): this;
  69 | }
  70 | 
  71 | /**
  72 |  * @category Provider
  73 |  */
  74 | export type ProviderProperties = {
  75 |   /***
  76 |    * Provider or provider adapter to use
  77 |    * @default EverscaleProviderAdapter
  78 |    */
  79 |   provider?: Promise<Provider> | Provider | ProviderAdapter;
  80 | };
  81 | 
  82 | function getAdapter(properties: ProviderProperties): ProviderAdapter {
  83 |   if (!properties.provider) return new EverscaleProviderAdapter();
  84 |   return isProviderAdapter(properties.provider)
  85 |     ? properties.provider
  86 |     : new StaticProviderAdapter(properties.provider);
  87 | }
  88 | 
  89 | /**
  90 |  * @category Provider
  91 |  */
  92 | export class ProviderRpcClient {
  93 |   private readonly _adapter: ProviderAdapter;
  94 |   private readonly _api: RawProviderApiMethods;
  95 |   private readonly _initializationPromise: Promise<void>;
  96 |   private readonly _subscriptions: { [K in ProviderEvent]: Map<number, (data: ProviderEventData<K>) => void> } = {
  97 |     connected: new Map(),
  98 |     disconnected: new Map(),
  99 |     transactionsFound: new Map(),
 100 |     contractStateChanged: new Map(),
 101 |     messageStatusUpdated: new Map(),
 102 |     networkChanged: new Map(),
 103 |     permissionsChanged: new Map(),
 104 |     loggedOut: new Map(),
 105 |   };
 106 |   private readonly _contractSubscriptions: Map<string, Map<number, ContractUpdatesSubscription>> = new Map();
 107 |   private _provider?: Provider;
 108 | 
 109 |   public Contract: new <Abi>(abi: Abi, address: Address) => contract.Contract<Abi>;
 110 |   public Subscriber: new () => subscriber.Subscriber;
 111 | 
 112 |   constructor(properties: ProviderProperties = {}) {
 113 |     this._adapter = getAdapter(properties);
 114 | 
 115 |     const self = this;
 116 | 
 117 |     // Create contract proxy type
 118 |     class ProviderContract<Abi> extends contract.Contract<Abi> {
 119 |       constructor(abi: Abi, address: Address) {
 120 |         super(self, abi, address);
 121 |       }
 122 |     }
 123 | 
 124 |     this.Contract = ProviderContract;
 125 | 
 126 |     // Create subscriber proxy type
 127 |     class ProviderSubscriber extends subscriber.Subscriber {
 128 |       constructor() {
 129 |         super(self);
 130 |       }
 131 |     }
 132 | 
 133 |     this.Subscriber = ProviderSubscriber;
 134 | 
 135 |     // Wrap provider requests
 136 |     this._api = new Proxy(
 137 |       {},
 138 |       {
 139 |         get:
 140 |           <K extends ProviderMethod>(_object: ProviderRpcClient, method: K) =>
 141 |             (params: RawProviderApiRequestParams<K>) => {
 142 |               if (this._provider != null) {
 143 |                 return this._provider.request({ method, params });
 144 |               } else {
 145 |                 throw new ProviderNotInitializedException();
 146 |               }
 147 |             },
 148 |       },
 149 |     ) as unknown as RawProviderApiMethods;
 150 | 
 151 |     const providerPromise = Promise.resolve(this._adapter.getProvider());
 152 |     this._initializationPromise = providerPromise.then(provider => {
 153 |       this._provider = provider;
 154 |     });
 155 | 
 156 |     // Will only register handlers for successfully loaded injected provider
 157 |     this._initializationPromise.then(() => {
 158 |       if (this._provider) {
 159 |         this._registerEventHandlers(this._provider);
 160 |       }
 161 |     });
 162 |   }
 163 | 
 164 |   /**
 165 |    * Checks whether this page has injected Everscale provider or
 166 |    * there is a fallback provider.
 167 |    */
 168 |   public async hasProvider(): Promise<boolean> {
 169 |     return this._adapter.hasProvider();
 170 |   }
 171 | 
 172 |   /**
 173 |    * Waits until provider api will be available. Calls `fallback` if no provider was found
 174 |    *
 175 |    * @throws ProviderNotFoundException when no provider found
 176 |    */
 177 |   public async ensureInitialized(): Promise<void> {
 178 |     await this._initializationPromise;
 179 |     if (this._provider == null) {
 180 |       throw new ProviderNotFoundException();
 181 |     }
 182 |   }
 183 | 
 184 |   /**
 185 |    * Whether provider api is ready
 186 |    */
 187 |   public get isInitialized(): boolean {
 188 |     return this._provider != null;
 189 |   }
 190 | 
 191 |   /**
 192 |    * Raw provider
 193 |    */
 194 |   public get raw(): Provider {
 195 |     if (this._provider != null) {
 196 |       return this._provider;
 197 |     } else {
 198 |       throw new ProviderNotInitializedException();
 199 |     }
 200 |   }
 201 | 
 202 |   /**
 203 |    * Raw provider api
 204 |    */
 205 |   public get rawApi(): RawProviderApiMethods {
 206 |     return this._api;
 207 |   }
 208 | 
 209 |   /**
 210 |    * Creates typed contract wrapper.
 211 |    *
 212 |    * @param abi Readonly object (must be declared with `as const`)
 213 |    * @param address Default contract address
 214 |    *
 215 |    * @deprecated `new ever.Contract(abi, address)` should be used instead
 216 |    */
 217 |   public createContract<Abi>(abi: Abi, address: Address): contract.Contract<Abi> {
 218 |     return new this.Contract<Abi>(abi, address);
 219 |   }
 220 | 
 221 |   /**
 222 |    * Creates subscriptions group
 223 |    *
 224 |    * @deprecated `new ever.Subscriber()` should be used instead
 225 |    */
 226 |   public createSubscriber(): subscriber.Subscriber {
 227 |     return new this.Subscriber();
 228 |   }
 229 | 
 230 |   /**
 231 |    * Requests new permissions for current origin.
 232 |    * Shows an approval window to the user.
 233 |    * Will overwrite already existing permissions
 234 |    *
 235 |    * ---
 236 |    * Required permissions: none
 237 |    */
 238 |   public async requestPermissions(
 239 |     args: ProviderApiRequestParams<'requestPermissions'>,
 240 |   ): Promise<ProviderApiResponse<'requestPermissions'>> {
 241 |     await this.ensureInitialized();
 242 |     const result = await this._api.requestPermissions({
 243 |       permissions: args.permissions,
 244 |     });
 245 |     return parsePermissions(result);
 246 |   }
 247 | 
 248 |   /**
 249 |    * Updates `accountInteraction` permission value
 250 |    *
 251 |    * ---
 252 |    * Requires permissions: `accountInteraction`
 253 |    */
 254 |   public async changeAccount(): Promise<void> {
 255 |     await this.ensureInitialized();
 256 |     await this._api.changeAccount();
 257 |   }
 258 | 
 259 |   /**
 260 |    * Removes all permissions for current origin and stops all subscriptions
 261 |    */
 262 |   public async disconnect(): Promise<void> {
 263 |     await this.ensureInitialized();
 264 |     await this._api.disconnect();
 265 |   }
 266 | 
 267 |   /**
 268 |    * Called every time contract state changes
 269 |    */
 270 |   public subscribe(
 271 |     eventName: 'contractStateChanged',
 272 |     params: { address: Address },
 273 |   ): Promise<Subscription<'contractStateChanged'>>;
 274 | 
 275 |   /**
 276 |    * Called on each new transactions batch, received on subscription
 277 |    */
 278 |   public subscribe(
 279 |     eventName: 'transactionsFound',
 280 |     params: { address: Address },
 281 |   ): Promise<Subscription<'transactionsFound'>>;
 282 | 
 283 |   /**
 284 |    * Called every time when provider connection is established
 285 |    */
 286 |   public subscribe(eventName: 'connected'): Promise<Subscription<'connected'>>;
 287 | 
 288 |   /**
 289 |    * Called when inpage provider disconnects from extension
 290 |    */
 291 |   public subscribe(eventName: 'disconnected'): Promise<Subscription<'disconnected'>>;
 292 | 
 293 |   /**
 294 |    * Called every time a delayed message was delivered or expired
 295 |    */
 296 |   public subscribe(eventName: 'messageStatusUpdated'): Promise<Subscription<'messageStatusUpdated'>>;
 297 | 
 298 |   /**
 299 |    * Called each time the user changes network
 300 |    */
 301 |   public subscribe(eventName: 'networkChanged'): Promise<Subscription<'networkChanged'>>;
 302 | 
 303 |   /**
 304 |    * Called when permissions are changed.
 305 |    * Mostly when account has been removed from the current `accountInteraction` permission,
 306 |    * or disconnect method was called
 307 |    */
 308 |   public subscribe(eventName: 'permissionsChanged'): Promise<Subscription<'permissionsChanged'>>;
 309 | 
 310 |   /**
 311 |    * Called when the user logs out of the extension
 312 |    */
 313 |   public subscribe(eventName: 'loggedOut'): Promise<Subscription<'loggedOut'>>;
 314 | 
 315 |   public async subscribe<T extends ProviderEvent>(
 316 |     eventName: T,
 317 |     params?: { address: Address },
 318 |   ): Promise<Subscription<T>> {
 319 |     type Handler<K extends SubscriptionEvent, T extends ProviderEvent> = K extends 'data'
 320 |       ? (data: ProviderEventData<T>) => void
 321 |       : () => void;
 322 | 
 323 |     class SubscriptionImpl<T extends ProviderEvent> implements Subscription<T> {
 324 |       private readonly _listeners: { [K in SubscriptionEvent]: Handler<K, T>[] } = {
 325 |         data: [],
 326 |         subscribed: [],
 327 |         unsubscribed: [],
 328 |       };
 329 |       private _subscribed = false;
 330 | 
 331 |       constructor(
 332 |         private readonly _subscribe: (s: SubscriptionImpl<T>) => Promise<void>,
 333 |         private readonly _unsubscribe: () => Promise<void>,
 334 |       ) { }
 335 | 
 336 |       on(eventName: 'data', listener: (data: ProviderEventData<T>) => void): this;
 337 |       on(eventName: 'subscribed', listener: () => void): this;
 338 |       on(eventName: 'unsubscribed', listener: () => void): this;
 339 |       on<K extends SubscriptionEvent>(eventName: K, listener: Handler<K, T>): this {
 340 |         this._listeners[eventName].push(listener);
 341 |         return this;
 342 |       }
 343 | 
 344 |       subscribe = async (): Promise<void> => {
 345 |         if (this._subscribed) {
 346 |           return;
 347 |         }
 348 |         this._subscribed = true;
 349 | 
 350 |         await this._subscribe(this);
 351 |         for (const handler of this._listeners['subscribed']) {
 352 |           handler();
 353 |         }
 354 |       };
 355 | 
 356 |       unsubscribe = async (): Promise<void> => {
 357 |         if (!this._subscribed) {
 358 |           return;
 359 |         }
 360 |         this._subscribed = false;
 361 | 
 362 |         await this._unsubscribe();
 363 |         for (const handler of this._listeners['unsubscribed']) {
 364 |           handler();
 365 |         }
 366 |       };
 367 | 
 368 |       notify(data: ProviderEventData<T>) {
 369 |         for (const handler of this._listeners['data']) {
 370 |           handler(data);
 371 |         }
 372 |       }
 373 |     }
 374 | 
 375 |     const existingSubscriptions = this._subscriptions[eventName];
 376 | 
 377 |     const id = getUniqueId();
 378 | 
 379 |     switch (eventName) {
 380 |       case 'connected':
 381 |       case 'disconnected':
 382 |       case 'messageStatusUpdated':
 383 |       case 'networkChanged':
 384 |       case 'permissionsChanged':
 385 |       case 'loggedOut': {
 386 |         const subscription = new SubscriptionImpl<T>(
 387 |           async subscription => {
 388 |             if (existingSubscriptions.has(id)) {
 389 |               return;
 390 |             }
 391 |             existingSubscriptions.set(id, data => {
 392 |               subscription.notify(data);
 393 |             });
 394 |           },
 395 |           async () => {
 396 |             existingSubscriptions.delete(id);
 397 |           },
 398 |         );
 399 |         await subscription.subscribe();
 400 |         return subscription;
 401 |       }
 402 |       case 'transactionsFound':
 403 |       case 'contractStateChanged': {
 404 |         if (params == null) {
 405 |           throw new Error('Address must be specified for the subscription');
 406 |         }
 407 | 
 408 |         await this.ensureInitialized();
 409 | 
 410 |         const address = params.address.toString();
 411 | 
 412 |         const subscription = new SubscriptionImpl<T>(
 413 |           async subscription => {
 414 |             if (existingSubscriptions.has(id)) {
 415 |               return;
 416 |             }
 417 |             existingSubscriptions.set(id, ((data: ProviderEventData<'transactionsFound' | 'contractStateChanged'>) => {
 418 |               if (data.address.toString() === address) {
 419 |                 subscription.notify(data as ProviderEventData<T>);
 420 |               }
 421 |             }) as (data: ProviderEventData<T>) => void);
 422 | 
 423 |             let contractSubscriptions = this._contractSubscriptions.get(address);
 424 |             if (contractSubscriptions == null) {
 425 |               contractSubscriptions = new Map();
 426 |               this._contractSubscriptions.set(address, contractSubscriptions);
 427 |             }
 428 | 
 429 |             const subscriptionState = {
 430 |               state: eventName === 'contractStateChanged',
 431 |               transactions: eventName === 'transactionsFound',
 432 |             };
 433 |             contractSubscriptions.set(id, subscriptionState);
 434 | 
 435 |             const { total, withoutExcluded } = foldSubscriptions(contractSubscriptions.values(), subscriptionState);
 436 | 
 437 |             try {
 438 |               if (total.transactions !== withoutExcluded.transactions || total.state !== withoutExcluded.state) {
 439 |                 await this.rawApi.subscribe({ address, subscriptions: total });
 440 |               }
 441 |             } catch (e) {
 442 |               existingSubscriptions.delete(id);
 443 |               contractSubscriptions.delete(id);
 444 |               throw e;
 445 |             }
 446 |           },
 447 |           async () => {
 448 |             existingSubscriptions.delete(id);
 449 | 
 450 |             const contractSubscriptions = this._contractSubscriptions.get(address);
 451 |             if (contractSubscriptions == null) {
 452 |               return;
 453 |             }
 454 |             const updates = contractSubscriptions.get(id);
 455 | 
 456 |             const { total, withoutExcluded } = foldSubscriptions(contractSubscriptions.values(), updates);
 457 |             contractSubscriptions.delete(id);
 458 | 
 459 |             if (!withoutExcluded.transactions && !withoutExcluded.state) {
 460 |               await this.rawApi.unsubscribe({ address });
 461 |             } else if (total.transactions !== withoutExcluded.transactions || total.state !== withoutExcluded.state) {
 462 |               await this.rawApi.subscribe({ address, subscriptions: withoutExcluded });
 463 |             }
 464 |           },
 465 |         );
 466 |         await subscription.subscribe();
 467 |         return subscription;
 468 |       }
 469 |       default: {
 470 |         throw new Error(`Unknown event ${eventName}`);
 471 |       }
 472 |     }
 473 |   }
 474 | 
 475 |   /**
 476 |    * Returns provider api state
 477 |    *
 478 |    * ---
 479 |    * Required permissions: none
 480 |    */
 481 |   public async getProviderState(): Promise<ProviderApiResponse<'getProviderState'>> {
 482 |     await this.ensureInitialized();
 483 |     const state = await this._api.getProviderState();
 484 |     return {
 485 |       ...state,
 486 |       permissions: parsePermissions(state.permissions),
 487 |     } as ProviderApiResponse<'getProviderState'>;
 488 |   }
 489 | 
 490 |   /**
 491 |    * Requests contract balance
 492 |    *
 493 |    * ---
 494 |    * Required permissions: `basic`
 495 |    */
 496 |   public async getBalance(address: Address): Promise<string> {
 497 |     const { state } = await this.getFullContractState({
 498 |       address,
 499 |     });
 500 |     return state == null ? '0' : state?.balance;
 501 |   }
 502 | 
 503 |   /**
 504 |    * Requests contract data
 505 |    *
 506 |    * ---
 507 |    * Required permissions: `basic`
 508 |    */
 509 |   public async getFullContractState(
 510 |     args: ProviderApiRequestParams<'getFullContractState'>,
 511 |   ): Promise<ProviderApiResponse<'getFullContractState'>> {
 512 |     await this.ensureInitialized();
 513 |     return (await this._api.getFullContractState({
 514 |       address: args.address.toString(),
 515 |     })) as ProviderApiResponse<'getFullContractState'>;
 516 |   }
 517 | 
 518 |   /**
 519 |    * Compute storage fee
 520 |    *
 521 |    * ---
 522 |    * Required permissions: `basic`
 523 |    */
 524 |   public async computeStorageFee(
 525 |     args: ProviderApiRequestParams<'computeStorageFee'>,
 526 |   ): Promise<ProviderApiResponse<'computeStorageFee'>> {
 527 |     await this.ensureInitialized();
 528 |     return (await this._api.computeStorageFee({
 529 |       state: {
 530 |         boc: args.state.boc,
 531 |         balance: args.state.balance,
 532 |         genTimings: {
 533 |           ...args.state.genTimings,
 534 |         },
 535 |         lastTransactionId: args.state.lastTransactionId != null ? { ...args.state.lastTransactionId } : undefined,
 536 |         isDeployed: args.state.isDeployed,
 537 |         codeHash: args.state.codeHash,
 538 |       },
 539 |       masterchain: args.masterchain,
 540 |       timestamp: args.timestamp,
 541 |     })) as ProviderApiResponse<'computeStorageFee'>;
 542 |   }
 543 | 
 544 |   /**
 545 |    * Requests accounts with specified code hash
 546 |    *
 547 |    * ---
 548 |    * Required permissions: `basic`
 549 |    */
 550 |   public async getAccountsByCodeHash(
 551 |     args: ProviderApiRequestParams<'getAccountsByCodeHash'>,
 552 |   ): Promise<ProviderApiResponse<'getAccountsByCodeHash'>> {
 553 |     await this.ensureInitialized();
 554 |     const { accounts, continuation } = await this._api.getAccountsByCodeHash({
 555 |       ...args,
 556 |     });
 557 |     return {
 558 |       accounts: accounts.map(address => new Address(address)),
 559 |       continuation,
 560 |     } as ProviderApiResponse<'getAccountsByCodeHash'>;
 561 |   }
 562 | 
 563 |   /**
 564 |    * Requests contract transactions
 565 |    *
 566 |    * ---
 567 |    * Required permissions: `basic`
 568 |    */
 569 |   public async getTransactions(
 570 |     args: ProviderApiRequestParams<'getTransactions'>,
 571 |   ): Promise<ProviderApiResponse<'getTransactions'>> {
 572 |     await this.ensureInitialized();
 573 |     const { transactions, continuation, info } = await this._api.getTransactions({
 574 |       ...args,
 575 |       address: args.address.toString(),
 576 |     });
 577 |     return {
 578 |       transactions: transactions.map(parseTransaction),
 579 |       continuation,
 580 |       info,
 581 |     } as ProviderApiResponse<'getTransactions'>;
 582 |   }
 583 | 
 584 |   /**
 585 |    * Searches transaction by hash
 586 |    *
 587 |    * ---
 588 |    * Required permissions: `basic`
 589 |    */
 590 |   public async getTransaction(
 591 |     args: ProviderApiRequestParams<'getTransaction'>,
 592 |   ): Promise<ProviderApiResponse<'getTransaction'>> {
 593 |     await this.ensureInitialized();
 594 |     const { transaction } = await this._api.getTransaction({
 595 |       ...args,
 596 |     });
 597 |     return {
 598 |       transaction: transaction ? parseTransaction(transaction) : undefined,
 599 |     } as ProviderApiResponse<'getTransaction'>;
 600 |   }
 601 | 
 602 |   /**
 603 |    * Computes contract address from code and init params
 604 |    *
 605 |    * ---
 606 |    * Required permissions: `basic`
 607 |    */
 608 |   public async getExpectedAddress<Abi>(abi: Abi, args: GetExpectedAddressParams<Abi>): Promise<Address> {
 609 |     const { address } = await this.getStateInit(abi, args);
 610 |     return address;
 611 |   }
 612 | 
 613 |   /**
 614 |    * Computes contract address and state from code and init params
 615 |    *
 616 |    * ---
 617 |    * Required permissions: `basic`
 618 |    */
 619 |   public async getStateInit<Abi>(
 620 |     abi: Abi,
 621 |     args: GetExpectedAddressParams<Abi>,
 622 |   ): Promise<ProviderApiResponse<'getExpectedAddress'>> {
 623 |     await this.ensureInitialized();
 624 |     const { address, stateInit, hash } = await this._api.getExpectedAddress({
 625 |       abi: JSON.stringify(abi),
 626 |       ...args,
 627 |       initParams: serializeTokensObject(args.initParams),
 628 |     });
 629 |     return {
 630 |       address: new Address(address),
 631 |       stateInit,
 632 |       hash,
 633 |     };
 634 |   }
 635 | 
 636 |   /**
 637 |    * Decodes initial contract data using the specified ABI
 638 |    *
 639 |    * ---
 640 |    * Required permissions: `basic`
 641 |    */
 642 |   public async unpackInitData<Abi>(
 643 |     abi: Abi,
 644 |     data: string,
 645 |   ): Promise<{
 646 |     publicKey?: string;
 647 |     initParams: DecodedAbiInitData<Abi>;
 648 |   }> {
 649 |     await this.ensureInitialized();
 650 |     const { publicKey, initParams } = await this._api.unpackInitData({
 651 |       abi: JSON.stringify(abi),
 652 |       data,
 653 |     });
 654 |     return {
 655 |       publicKey,
 656 |       initParams: parsePartialTokensObject((abi as any).data as AbiParam[], initParams) as DecodedAbiInitData<Abi>,
 657 |     };
 658 |   }
 659 | 
 660 |   /**
 661 |    * Computes hash of base64 encoded BOC
 662 |    *
 663 |    * ---
 664 |    * Required permissions: `basic`
 665 |    */
 666 |   public async getBocHash(boc: string): Promise<string> {
 667 |     await this.ensureInitialized();
 668 |     return await this._api
 669 |       .getBocHash({
 670 |         boc,
 671 |       })
 672 |       .then(({ hash }) => hash);
 673 |   }
 674 | 
 675 |   /**
 676 |    * Creates base64 encoded BOC
 677 |    *
 678 |    * ---
 679 |    * Required permissions: `basic`
 680 |    */
 681 |   public async packIntoCell<P extends readonly ReadonlyAbiParam[]>(args: {
 682 |     abiVersion?: AbiVersion;
 683 |     structure: P;
 684 |     data: MergeInputObjectsArray<P>;
 685 |   }): Promise<ProviderApiResponse<'packIntoCell'>> {
 686 |     await this.ensureInitialized();
 687 |     return (await this._api.packIntoCell({
 688 |       abiVersion: args.abiVersion,
 689 |       structure: args.structure as unknown as AbiParam[],
 690 |       data: serializeTokensObject(args.data),
 691 |     })) as ProviderApiResponse<'packIntoCell'>;
 692 |   }
 693 | 
 694 |   /**
 695 |    * Decodes base64 encoded BOC
 696 |    *
 697 |    * ---
 698 |    * Required permissions: `basic`
 699 |    */
 700 |   public async unpackFromCell<P extends readonly ReadonlyAbiParam[]>(args: {
 701 |     abiVersion?: AbiVersion;
 702 |     structure: P;
 703 |     boc: string;
 704 |     allowPartial: boolean;
 705 |   }): Promise<{ data: MergeOutputObjectsArray<P> }> {
 706 |     await this.ensureInitialized();
 707 |     const { data } = await this._api.unpackFromCell({
 708 |       ...args,
 709 |       structure: args.structure as unknown as AbiParam[],
 710 |     });
 711 |     return {
 712 |       data: parseTokensObject(args.structure as unknown as AbiParam[], data) as MergeOutputObjectsArray<P>,
 713 |     };
 714 |   }
 715 | 
 716 |   /**
 717 |    * Extracts public key from raw account state
 718 |    *
 719 |    * **NOTE:** can only be used on contracts which are deployed and has `pubkey` header
 720 |    *
 721 |    * ---
 722 |    * Required permissions: `basic`
 723 |    */
 724 |   public async extractPublicKey(boc: string): Promise<string> {
 725 |     await this.ensureInitialized();
 726 |     const { publicKey } = await this._api.extractPublicKey({
 727 |       boc,
 728 |     });
 729 |     return publicKey;
 730 |   }
 731 | 
 732 |   /**
 733 |    * Converts base64 encoded contract code into tvc with default init data
 734 |    *
 735 |    * ---
 736 |    * Required permissions: `basic`
 737 |    */
 738 |   public async codeToTvc(code: string): Promise<string> {
 739 |     await this.ensureInitialized();
 740 |     const { tvc } = await this._api.codeToTvc({
 741 |       code,
 742 |     });
 743 |     return tvc;
 744 |   }
 745 | 
 746 |   /**
 747 |    * Merges code and data into state init
 748 |    *
 749 |    * ---
 750 |    * Required permissions: `basic`
 751 |    */
 752 |   public async mergeTvc(args: ProviderApiRequestParams<'mergeTvc'>): Promise<ProviderApiResponse<'mergeTvc'>> {
 753 |     await this.ensureInitialized();
 754 |     return await this._api.mergeTvc(args);
 755 |   }
 756 | 
 757 |   /**
 758 |    * Splits base64 encoded state init into code and data
 759 |    *
 760 |    * ---
 761 |    * Required permissions: `basic`
 762 |    */
 763 |   public async splitTvc(tvc: string): Promise<ProviderApiResponse<'splitTvc'>> {
 764 |     await this.ensureInitialized();
 765 |     return await this._api.splitTvc({
 766 |       tvc,
 767 |     });
 768 |   }
 769 | 
 770 |   /**
 771 |    * Merges code and data into state init
 772 |    *
 773 |    * ---
 774 |    * Required permissions: `basic`
 775 |    */
 776 |   public async setCodeSalt<P extends readonly ReadonlyAbiParam[]>(
 777 |     args: SetCodeSaltParams<P>,
 778 |   ): Promise<ProviderApiResponse<'setCodeSalt'>> {
 779 |     let salt;
 780 |     if (typeof args.salt === 'string') {
 781 |       await this.ensureInitialized();
 782 |       salt = args.salt;
 783 |     } else {
 784 |       const { boc } = await this.packIntoCell(args.salt);
 785 |       salt = boc;
 786 |     }
 787 |     return await this._api.setCodeSalt({ code: args.code, salt });
 788 |   }
 789 | 
 790 |   /**
 791 |    * Retrieves salt from code. Returns undefined if code doesn't contain salt
 792 |    *
 793 |    * ---
 794 |    * Required permissions: `basic`
 795 |    */
 796 |   public async getCodeSalt(args: GetCodeSaltParams): Promise<string | undefined> {
 797 |     await this.ensureInitialized();
 798 |     const { salt } = await this.rawApi.getCodeSalt({
 799 |       code: args.code,
 800 |     });
 801 |     return salt;
 802 |   }
 803 | 
 804 |   /**
 805 |    * Adds asset to the selected account
 806 |    *
 807 |    * ---
 808 |    * Requires permissions: `accountInteraction`
 809 |    */
 810 |   public async addAsset<T extends AssetType>(args: AddAssetParams<T>): Promise<ProviderApiResponse<'addAsset'>> {
 811 |     await this.ensureInitialized();
 812 |     let params: AssetTypeParams<T, string>;
 813 |     switch (args.type) {
 814 |       case 'tip3_token': {
 815 |         params = {
 816 |           rootContract: args.params.rootContract.toString(),
 817 |         } as AssetTypeParams<T, string>;
 818 |         break;
 819 |       }
 820 |       default:
 821 |         throw new Error('Unknown asset type');
 822 |     }
 823 | 
 824 |     return await this._api.addAsset({
 825 |       account: args.account.toString(),
 826 |       type: args.type,
 827 |       params,
 828 |     });
 829 |   }
 830 | 
 831 |   public async verifySignature(
 832 |     args: ProviderApiRequestParams<'verifySignature'>,
 833 |   ): Promise<ProviderApiResponse<'verifySignature'>> {
 834 |     await this.ensureInitialized();
 835 |     return await this._api.verifySignature(args);
 836 |   }
 837 | 
 838 |   /**
 839 |    * Signs arbitrary data.
 840 |    *
 841 |    * NOTE: hashes data before signing. Use `signDataRaw` to sign without hash.
 842 |    *
 843 |    * ---
 844 |    * Requires permissions: `accountInteraction`
 845 |    */
 846 |   public async signData(args: ProviderApiRequestParams<'signData'>): Promise<ProviderApiResponse<'signData'>> {
 847 |     await this.ensureInitialized();
 848 |     return await this._api.signData(args);
 849 |   }
 850 | 
 851 |   /**
 852 |    * Signs arbitrary data without hashing it
 853 |    *
 854 |    * ---
 855 |    * Requires permissions: `accountInteraction`
 856 |    */
 857 |   public async signDataRaw(args: ProviderApiRequestParams<'signDataRaw'>): Promise<ProviderApiResponse<'signDataRaw'>> {
 858 |     await this.ensureInitialized();
 859 |     return await this._api.signDataRaw(args);
 860 |   }
 861 | 
 862 |   /**
 863 |    * Encrypts arbitrary data with specified algorithm for each specified recipient
 864 |    *
 865 |    * ---
 866 |    * Requires permissions: `accountInteraction`
 867 |    */
 868 |   public async encryptData(args: ProviderApiRequestParams<'encryptData'>): Promise<EncryptedData[]> {
 869 |     await this.ensureInitialized();
 870 |     const { encryptedData } = await this._api.encryptData(args);
 871 |     return encryptedData;
 872 |   }
 873 | 
 874 |   /**
 875 |    * Decrypts encrypted data. Returns base64 encoded data
 876 |    *
 877 |    * ---
 878 |    * Requires permissions: `accountInteraction`
 879 |    */
 880 |   public async decryptData(encryptedData: EncryptedData): Promise<string> {
 881 |     await this.ensureInitialized();
 882 |     const { data } = await this._api.decryptData({ encryptedData });
 883 |     return data;
 884 |   }
 885 | 
 886 |   /**
 887 |    * Sends an internal message from the user account.
 888 |    * Shows an approval window to the user.
 889 |    *
 890 |    * ---
 891 |    * Required permissions: `accountInteraction`
 892 |    */
 893 |   public async sendMessage(args: ProviderApiRequestParams<'sendMessage'>): Promise<ProviderApiResponse<'sendMessage'>> {
 894 |     await this.ensureInitialized();
 895 |     const { transaction } = await this._api.sendMessage({
 896 |       sender: args.sender.toString(),
 897 |       recipient: args.recipient.toString(),
 898 |       amount: args.amount,
 899 |       bounce: args.bounce,
 900 |       payload: args.payload
 901 |         ? {
 902 |           abi: args.payload.abi,
 903 |           method: args.payload.method,
 904 |           params: serializeTokensObject(args.payload.params),
 905 |         }
 906 |         : undefined,
 907 |       stateInit: args.stateInit,
 908 |       ignoredActionPhaseCodes: args.ignoredActionPhaseCodes?.map(serializeIgnoreCode),
 909 |       ignoredComputePhaseCodes: args.ignoredComputePhaseCodes?.map(serializeIgnoreCode),
 910 |     });
 911 |     return {
 912 |       transaction: parseTransaction(transaction),
 913 |     };
 914 |   }
 915 | 
 916 |   /**
 917 |    * Sends an internal message from the user account without waiting for the transaction.
 918 |    * Shows an approval window to the user.
 919 |    *
 920 |    * @see messageStatusUpdated
 921 |    *
 922 |    * ---
 923 |    * Required permissions: `accountInteraction`
 924 |    */
 925 |   public async sendMessageDelayed(
 926 |     args: ProviderApiRequestParams<'sendMessageDelayed'>,
 927 |   ): Promise<contract.DelayedMessageExecution> {
 928 |     await this.ensureInitialized();
 929 | 
 930 |     const transactions = new DelayedTransactions();
 931 | 
 932 |     const subscription = await this.subscribe('messageStatusUpdated');
 933 |     subscription.on('data', data => {
 934 |       if (!data.address.equals(args.sender)) {
 935 |         return;
 936 |       }
 937 |       transactions.fillTransaction(data.hash, data.transaction);
 938 |     });
 939 | 
 940 |     const { message } = await this._api
 941 |       .sendMessageDelayed({
 942 |         sender: args.sender.toString(),
 943 |         recipient: args.recipient.toString(),
 944 |         amount: args.amount,
 945 |         bounce: args.bounce,
 946 |         payload: args.payload
 947 |           ? {
 948 |             abi: args.payload.abi,
 949 |             method: args.payload.method,
 950 |             params: serializeTokensObject(args.payload.params),
 951 |           }
 952 |           : undefined,
 953 |         stateInit: args.stateInit,
 954 |         ignoredActionPhaseCodes: args.ignoredActionPhaseCodes?.map(serializeIgnoreCode),
 955 |         ignoredComputePhaseCodes: args.ignoredComputePhaseCodes?.map(serializeIgnoreCode),
 956 |       })
 957 |       .catch(e => {
 958 |         subscription.unsubscribe().catch(console.error);
 959 |         throw e;
 960 |       });
 961 | 
 962 |     const transaction = transactions
 963 |       .waitTransaction(args.sender, message.hash)
 964 |       .finally(() => subscription.unsubscribe().catch(console.error));
 965 | 
 966 |     return {
 967 |       messageHash: message.hash,
 968 |       expireAt: message.expireAt,
 969 |       transaction,
 970 |     };
 971 |   }
 972 | 
 973 |   /**
 974 |    * Request user to add a new network.
 975 |    * Shows an approval window to the user.
 976 |    *
 977 |    * ---
 978 |    * Required permissions: `basic`
 979 |    */
 980 |   public async addNetwork(args: ProviderApiRequestParams<'addNetwork'>): Promise<ProviderApiResponse<'addNetwork'>> {
 981 |     await this.ensureInitialized();
 982 |     return await this._api.addNetwork(args);
 983 |   }
 984 | 
 985 |   /**
 986 |    * Request user to change selected network.
 987 |    * Shows an approval window to the user.
 988 |    *
 989 |    * ---
 990 |    * Required permissions: `basic`
 991 |    */
 992 |   public async changeNetwork(
 993 |     args: ProviderApiRequestParams<'changeNetwork'>,
 994 |   ): Promise<ProviderApiResponse<'changeNetwork'>> {
 995 |     await this.ensureInitialized();
 996 |     return await this._api.changeNetwork(args);
 997 |   }
 998 | 
 999 |   private _registerEventHandlers(provider: Provider) {
1000 |     const knownEvents: { [K in ProviderEvent]: (data: RawProviderEventData<K>) => ProviderEventData<K> } = {
1001 |       connected: data => data,
1002 |       disconnected: data => data,
1003 |       transactionsFound: data => ({
1004 |         address: new Address(data.address),
1005 |         transactions: data.transactions.map(parseTransaction),
1006 |         info: data.info,
1007 |       }),
1008 |       contractStateChanged: data => ({
1009 |         address: new Address(data.address),
1010 |         state: data.state,
1011 |       }),
1012 |       messageStatusUpdated: data => ({
1013 |         address: new Address(data.address),
1014 |         hash: data.hash,
1015 |         transaction: data.transaction != null ? parseTransaction(data.transaction) : undefined,
1016 |       }),
1017 |       networkChanged: data => data,
1018 |       permissionsChanged: data => ({
1019 |         permissions: parsePermissions(data.permissions),
1020 |       }),
1021 |       loggedOut: data => data,
1022 |     };
1023 | 
1024 |     for (const [eventName, extractor] of Object.entries(knownEvents)) {
1025 |       provider.addListener(eventName as ProviderEvent, data => {
1026 |         const handlers = this._subscriptions[eventName as ProviderEvent];
1027 |         const parsed = (extractor as any)(data);
1028 |         for (const handler of handlers.values()) {
1029 |           handler(parsed);
1030 |         }
1031 |       });
1032 |     }
1033 |   }
1034 | }
1035 | 
1036 | /**
1037 |  * @category Provider
1038 |  */
1039 | export interface Subscription<T extends ProviderEvent> {
1040 |   /**
1041 |    * Fires on each incoming event with the event object as argument.
1042 |    *
1043 |    * @param eventName 'data'
1044 |    * @param listener
1045 |    */
1046 |   on(eventName: 'data', listener: (data: ProviderEventData<T>) => void): this;
1047 | 
1048 |   /**
1049 |    * Fires on successful re-subscription
1050 |    *
1051 |    * @param eventName 'subscribed'
1052 |    * @param listener
1053 |    */
1054 |   on(eventName: 'subscribed', listener: () => void): this;
1055 | 
1056 |   /**
1057 |    * Fires on unsubscription
1058 |    *
1059 |    * @param eventName 'unsubscribed'
1060 |    * @param listener
1061 |    */
1062 |   on(eventName: 'unsubscribed', listener: () => void): this;
1063 | 
1064 |   /**
1065 |    * Can be used to re-subscribe with the same parameters.
1066 |    */
1067 |   subscribe: () => Promise<void>;
1068 | 
1069 |   /**
1070 |    * Unsubscribes the subscription.
1071 |    */
1072 |   unsubscribe: () => Promise<void>;
1073 | }
1074 | 
1075 | type SubscriptionEvent = 'data' | 'subscribed' | 'unsubscribed';
1076 | 
1077 | /**
1078 |  * @category Provider
1079 |  */
1080 | export class ProviderNotFoundException extends Error {
1081 |   constructor() {
1082 |     super('Everscale provider was not found');
1083 |   }
1084 | }
1085 | 
1086 | /**
1087 |  * @category Provider
1088 |  */
1089 | export class ProviderNotInitializedException extends Error {
1090 |   constructor() {
1091 |     super('Everscale provider was not initialized yet');
1092 |   }
1093 | }
1094 | 
1095 | /**
1096 |  * @category Provider
1097 |  */
1098 | export type RawRpcMethod<P extends ProviderMethod> =
1099 |   RawProviderApiRequestParams<P> extends undefined
1100 |   ? () => Promise<RawProviderApiResponse<P>>
1101 |   : (args: RawProviderApiRequestParams<P>) => Promise<RawProviderApiResponse<P>>;
1102 | 
1103 | /**
1104 |  * @category Provider
1105 |  */
1106 | export type RawProviderApiMethods = {
1107 |   [P in ProviderMethod]: RawRpcMethod<P>;
1108 | };
1109 | 
1110 | /**
1111 |  * @category Provider
1112 |  */
1113 | export type GetExpectedAddressParams<Abi> = Abi extends { data: infer D }
1114 |   ? {
1115 |     /**
1116 |      * Base64 encoded TVC file
1117 |      */
1118 |     tvc: string;
1119 |     /**
1120 |      * Contract workchain. 0 by default
1121 |      */
1122 |     workchain?: number;
1123 |     /**
1124 |      * Public key, which will be injected into the contract. 0 by default
1125 |      */
1126 |     publicKey?: string;
1127 |     /**
1128 |      * State init params
1129 |      */
1130 |     initParams: MergeInputObjectsArray<D>;
1131 |   }
1132 |   : never;
1133 | 
1134 | /**
1135 |  * @category Provider
1136 |  */
1137 | export type SetCodeSaltParams<P extends readonly ReadonlyAbiParam[]> = {
1138 |   /**
1139 |    * Base64 encoded contract code
1140 |    */
1141 |   code: string;
1142 |   /**
1143 |    * Base64 encoded salt (as BOC) or params of boc encoder
1144 |    */
1145 |   salt:
1146 |   | string
1147 |   | {
1148 |     /**
1149 |      * ABI version. 2.2 if not specified otherwise
1150 |      */
1151 |     abiVersion?: AbiVersion;
1152 |     /**
1153 |      * Cell structure
1154 |      */
1155 |     structure: P;
1156 |     /**
1157 |      * Cell data
1158 |      */
1159 |     data: MergeInputObjectsArray<P>;
1160 |   };
1161 | };
1162 | 
1163 | /**
1164 |  * @category Provider
1165 |  */
1166 | export type GetCodeSaltParams = {
1167 |   /**
1168 |    * Base64 encoded contract code
1169 |    */
1170 |   code: string;
1171 | };
1172 | 
1173 | /**
1174 |  * @category Provider
1175 |  */
1176 | export type AddAssetParams<T extends AssetType> = {
1177 |   /**
1178 |    * Owner's wallet address.
1179 |    * It is the same address as the `accountInteraction.address`, but it must be explicitly provided
1180 |    */
1181 |   account: Address;
1182 |   /**
1183 |    * Which asset to add
1184 |    */
1185 |   type: T;
1186 |   /**
1187 |    * Asset parameters
1188 |    */
1189 |   params: AssetTypeParams<T>;
1190 | };
1191 | 
1192 | function foldSubscriptions(
1193 |   subscriptions: Iterable<ContractUpdatesSubscription>,
1194 |   except?: ContractUpdatesSubscription,
1195 | ): { total: ContractUpdatesSubscription; withoutExcluded: ContractUpdatesSubscription } {
1196 |   const total = { state: false, transactions: false };
1197 |   const withoutExcluded = Object.assign({}, total);
1198 | 
1199 |   for (const item of subscriptions) {
1200 |     if (withoutExcluded.transactions && withoutExcluded.state) {
1201 |       break;
1202 |     }
1203 | 
1204 |     total.state ||= item.state;
1205 |     total.transactions ||= item.transactions;
1206 |     if (item !== except) {
1207 |       withoutExcluded.state ||= item.state;
1208 |       withoutExcluded.transactions ||= item.transactions;
1209 |     }
1210 |   }
1211 | 
1212 |   return { total, withoutExcluded };
1213 | }
1214 | 


--------------------------------------------------------------------------------
/src/contract.ts:
--------------------------------------------------------------------------------
   1 | import { Address, UniqueArray, DelayedTransactions, LT_COLLATOR } from './utils';
   2 | import {
   3 |   AbiParam,
   4 |   AbiFunction,
   5 |   AbiEvent,
   6 |   AbiFields,
   7 |   FullContractState,
   8 |   RawTokensObject,
   9 |   TokensObject,
  10 |   Transaction,
  11 |   Message,
  12 |   AbiFunctionName,
  13 |   AbiEventName,
  14 |   AbiFieldName,
  15 |   AbiFunctionInputs,
  16 |   DecodedAbiFunctionOutputs,
  17 |   DecodedAbiFunctionInputs,
  18 |   DecodedAbiFields,
  19 |   AbiFunctionInputsWithDefault,
  20 |   DecodedAbiEventData,
  21 |   TransactionId,
  22 |   serializeTokensObject,
  23 |   parseTransaction,
  24 |   parseTokensObject,
  25 |   serializeTransaction,
  26 |   IgnoreTransactionTreeSimulationError,
  27 |   serializeIgnoreCode,
  28 |   AbiGetterName,
  29 |   AbiGetter,
  30 |   AbiGetterInputsWithDefault,
  31 |   DecodedAbiGetterOutputs,
  32 |   AbiGetterInputs,
  33 | } from './models';
  34 | import { Stream, Subscriber } from './stream';
  35 | import { ProviderApiResponse, ProviderRpcClient } from './index';
  36 | 
  37 | /**
  38 |  * @category Contract
  39 |  */
  40 | export class Contract<Abi> {
  41 |   private readonly _provider: ProviderRpcClient;
  42 |   private readonly _abi: string;
  43 |   private readonly _address: Address;
  44 |   private readonly _methods: ContractMethods<Abi>;
  45 |   private readonly _getters: ContractGetters<Abi>;
  46 |   private readonly _fields: ContractFields<Abi>;
  47 | 
  48 |   public readonly methodsAbi: { [K in AbiFunctionName<Abi>]: AbiFunction<Abi, K> };
  49 |   public readonly gettersAbi: { [K in AbiGetterName<Abi>]: AbiGetter<Abi, K> };
  50 |   public readonly eventsAbi: { [K in AbiEventName<Abi>]: AbiEvent<Abi, K> };
  51 |   public readonly fieldsAbi: AbiFields<Abi>;
  52 | 
  53 |   constructor(provider: ProviderRpcClient, abi: Abi, address: Address) {
  54 |     type ContractFunction = { name: string; inputs?: AbiParam[]; outputs?: AbiParam[] };
  55 | 
  56 |     if (!Array.isArray((abi as any).functions)) {
  57 |       throw new Error('Invalid abi. Functions array required');
  58 |     }
  59 |     if (!Array.isArray((abi as any).events)) {
  60 |       throw new Error('Invalid abi. Events array required');
  61 |     }
  62 | 
  63 |     this._provider = provider;
  64 |     this._abi = JSON.stringify(abi);
  65 |     this.methodsAbi = ((abi as any).functions as ContractFunction[]).reduce((functions, item) => {
  66 |       if (item.inputs == null) {
  67 |         item.inputs = [];
  68 |       }
  69 |       if (item.outputs == null) {
  70 |         item.outputs = [];
  71 |       }
  72 | 
  73 |       (functions as any)[item.name] = item;
  74 |       return functions;
  75 |     }, {} as typeof Contract.prototype.methodsAbi);
  76 | 
  77 |     this.gettersAbi = (((abi as any).getters ?? []) as ContractFunction[]).reduce((getters, item) => {
  78 |       if (item.inputs == null) {
  79 |         item.inputs = [];
  80 |       }
  81 |       if (item.outputs == null) {
  82 |         item.outputs = [];
  83 |       }
  84 | 
  85 |       (getters as any)[item.name] = item;
  86 |       return getters;
  87 |     }, {} as typeof Contract.prototype.gettersAbi);
  88 | 
  89 |     this.eventsAbi = ((abi as any).events as ContractFunction[]).reduce((events, item) => {
  90 |       if (item.inputs == null) {
  91 |         item.inputs = [];
  92 |       }
  93 |       (events as any)[item.name] = item;
  94 |       return events;
  95 |     }, {} as typeof Contract.prototype.eventsAbi);
  96 |     this.fieldsAbi = (abi as any).fields;
  97 | 
  98 |     this._address = address;
  99 | 
 100 |     this._methods = new Proxy(
 101 |       {},
 102 |       {
 103 |         get: <K extends AbiFunctionName<Abi>>(_object: Record<string, unknown>, method: K) => {
 104 |           const rawAbi = this.methodsAbi[method];
 105 |           return (params: TokensObject = {}) =>
 106 |             new ContractMethodImpl(this._provider, rawAbi, this._abi, this._address, method, params);
 107 |         },
 108 |       },
 109 |     ) as unknown as ContractMethods<Abi>;
 110 | 
 111 |     this._getters = new Proxy(
 112 |       {},
 113 |       {
 114 |         get: <K extends AbiGetterName<Abi>>(_object: Record<string, unknown>, getter: K) => {
 115 |           const rawAbi = this.gettersAbi[getter];
 116 |           return (params: TokensObject = {}) =>
 117 |             new ContractGetterImpl(this._provider, rawAbi, this._abi, this._address, getter, params);
 118 |         },
 119 |       },
 120 |     ) as unknown as ContractGetters<Abi>;
 121 | 
 122 |     this._fields = new Proxy(
 123 |       {},
 124 |       {
 125 |         get: <K extends AbiFieldName<Abi>>(_object: Record<string, unknown>, field: K) => {
 126 |           return async (params: GetContractFieldsParams = {}) => {
 127 |             await this._provider.ensureInitialized();
 128 |             const { fields, state } = await this._provider.rawApi.getContractFields({
 129 |               address: this._address.toString(),
 130 |               abi: this._abi,
 131 |               cachedState: params?.cachedState,
 132 |               allowPartial: params?.allowPartial == null ? false : params.allowPartial,
 133 |             });
 134 |             if (fields == null) {
 135 |               if (state == null) {
 136 |                 throw new Error('Account does not exist');
 137 |               } else if (!state.isDeployed) {
 138 |                 throw new Error('Account is not deployed');
 139 |               } else {
 140 |                 throw new Error('Invalid account data');
 141 |               }
 142 |             }
 143 |             const parsedFields = parseTokensObject(this.fieldsAbi as AbiParam[], fields) as DecodedAbiFields<Abi>;
 144 |             if (parsedFields == null || !Object.prototype.hasOwnProperty.call(parsedFields, field)) {
 145 |               throw new Error('Unknown field');
 146 |             }
 147 |             return parsedFields[field];
 148 |           };
 149 |         },
 150 |       },
 151 |     ) as unknown as ContractFields<Abi>;
 152 |   }
 153 | 
 154 |   public get methods(): ContractMethods<Abi> {
 155 |     return this._methods;
 156 |   }
 157 | 
 158 |   public get getters(): ContractGetters<Abi> {
 159 |     return this._getters;
 160 |   }
 161 | 
 162 |   public get fields(): ContractFields<Abi> {
 163 |     return this._fields;
 164 |   }
 165 | 
 166 |   public get address(): Address {
 167 |     return this._address;
 168 |   }
 169 | 
 170 |   public get abi(): string {
 171 |     return this._abi;
 172 |   }
 173 | 
 174 |   /**
 175 |    * Requests contract data
 176 |    *
 177 |    * ---
 178 |    * Required permissions: `basic`
 179 |    */
 180 |   public async getFullState(): Promise<ProviderApiResponse<'getFullContractState'>> {
 181 |     await this._provider.ensureInitialized();
 182 |     return (await this._provider.rawApi.getFullContractState({
 183 |       address: this.address.toString(),
 184 |     })) as ProviderApiResponse<'getFullContractState'>;
 185 |   }
 186 | 
 187 |   /**
 188 |    * Unpacks all fields from the contract state using the specified ABI
 189 |    *
 190 |    * ---
 191 |    * Required permissions: `basic`
 192 |    */
 193 |   public async getFields(args: GetContractFieldsParams = {}): Promise<{
 194 |     fields?: DecodedAbiFields<Abi>;
 195 |     state?: FullContractState;
 196 |   }> {
 197 |     await this._provider.ensureInitialized();
 198 |     const { fields, state } = await this._provider.rawApi.getContractFields({
 199 |       address: this.address.toString(),
 200 |       abi: this._abi,
 201 |       cachedState: args.cachedState,
 202 |       allowPartial: args.allowPartial == null ? false : args.allowPartial,
 203 |     });
 204 |     return {
 205 |       fields:
 206 |         fields != null ? (parseTokensObject(this.fieldsAbi as AbiParam[], fields) as DecodedAbiFields<Abi>) : undefined,
 207 |       state,
 208 |     };
 209 |   }
 210 | 
 211 |   /**
 212 |    * Creates new contract transactions stream
 213 |    *
 214 |    * @param subscriber
 215 |    */
 216 |   public transactions(subscriber: Subscriber): Stream<unknown, Transaction> {
 217 |     return subscriber.transactions(this._address).flatMap(({ transactions }) => transactions);
 218 |   }
 219 | 
 220 |   /**
 221 |    * Creates new contract events stream
 222 |    *
 223 |    * @param subscriber
 224 |    */
 225 |   public events(subscriber: Subscriber): Stream<unknown, DecodedEventWithTransaction<Abi, AbiEventName<Abi>>> {
 226 |     return subscriber
 227 |       .transactions(this._address)
 228 |       .flatMap(({ transactions }) => transactions)
 229 |       .flatMap(tx =>
 230 |         this.decodeTransactionEvents({ transaction: tx }).then(events => {
 231 |           events.forEach(event => ((event as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>).transaction = tx));
 232 |           return events as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>[];
 233 |         }),
 234 |       );
 235 |   }
 236 | 
 237 |   public async waitForEvent<E extends AbiEventName<Abi> = AbiEventName<Abi>>(
 238 |     args: WaitForEventParams<Abi, E> = {},
 239 |   ): Promise<DecodedEvent<Abi, E> | undefined> {
 240 |     const { range, filter } = args;
 241 |     const filterFn =
 242 |       typeof filter === 'string'
 243 |         ? ({ event }: DecodedEventWithTransaction<Abi, AbiEventName<Abi>>) => event === filter
 244 |         : filter;
 245 | 
 246 |     let subscriber = args.subscriber;
 247 |     const hasTempSubscriber = subscriber == null;
 248 |     if (subscriber == null) {
 249 |       subscriber = new this._provider.Subscriber();
 250 |     }
 251 | 
 252 |     const event = await (range?.fromLt != null || range?.fromUtime != null
 253 |       ? subscriber.oldTransactions(this._address, range).merge(subscriber.transactions(this._address))
 254 |       : subscriber.transactions(this.address)
 255 |     )
 256 |       .flatMap(item => item.transactions)
 257 |       .takeWhile(
 258 |         item =>
 259 |           range == null ||
 260 |           ((range.fromLt == null || LT_COLLATOR.compare(item.id.lt, range.fromLt) > 0) &&
 261 |             (range.fromUtime == null || item.createdAt > range.fromUtime) &&
 262 |             (range.toLt == null || LT_COLLATOR.compare(item.id.lt, range.toLt) < 0) &&
 263 |             (range.toUtime == null || item.createdAt < range.toUtime)),
 264 |       )
 265 |       .flatMap(tx =>
 266 |         this.decodeTransactionEvents({ transaction: tx }).then(events => {
 267 |           events.forEach(event => ((event as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>).transaction = tx));
 268 |           return events as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>[];
 269 |         }),
 270 |       )
 271 |       .filterMap(async event => {
 272 |         if (filterFn == null || (await filterFn(event))) {
 273 |           return event;
 274 |         } else {
 275 |           return undefined;
 276 |         }
 277 |       })
 278 |       .first();
 279 | 
 280 |     hasTempSubscriber && (await subscriber.unsubscribe());
 281 | 
 282 |     return event;
 283 |   }
 284 | 
 285 |   public async getPastEvents<E extends AbiEventName<Abi> = AbiEventName<Abi>>(
 286 |     args: GetPastEventParams<Abi, E>,
 287 |   ): Promise<EventsBatch<Abi, E>> {
 288 |     const { range, filter, limit } = args;
 289 |     const filterFn =
 290 |       typeof filter === 'string'
 291 |         ? ({ event }: DecodedEventWithTransaction<Abi, AbiEventName<Abi>>) => event === filter
 292 |         : filter;
 293 | 
 294 |     const result: DecodedEventWithTransaction<Abi, E>[] = [];
 295 |     let currentContinuation = args?.continuation;
 296 | 
 297 |     outer: while (true) {
 298 |       const { transactions, continuation } = await this._provider.getTransactions({
 299 |         address: this._address,
 300 |         continuation: currentContinuation,
 301 |       });
 302 |       if (transactions.length === null) {
 303 |         break;
 304 |       }
 305 | 
 306 |       const filteredTransactions = transactions.filter(
 307 |         item =>
 308 |           (range?.fromLt == null || LT_COLLATOR.compare(item.id.lt, range.fromLt) > 0) &&
 309 |           (range?.fromUtime == null || item.createdAt > range.fromUtime) &&
 310 |           (range?.toLt == null || LT_COLLATOR.compare(item.id.lt, range.toLt) < 0) &&
 311 |           (range?.toUtime == null || item.createdAt < range.toUtime),
 312 |       );
 313 | 
 314 |       if (filteredTransactions.length > 0) {
 315 |         const parsedEvents = await Promise.all(
 316 |           filteredTransactions.map(async tx => {
 317 |             return {
 318 |               tx,
 319 |               events: await this.decodeTransactionEvents({ transaction: tx }).then(events => {
 320 |                 events.forEach(
 321 |                   event => ((event as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>).transaction = tx),
 322 |                 );
 323 |                 return events as DecodedEventWithTransaction<Abi, AbiEventName<Abi>>[];
 324 |               }),
 325 |             };
 326 |           }),
 327 |         );
 328 | 
 329 |         for (let { tx, events } of parsedEvents) {
 330 |           if (filterFn != null) {
 331 |             events = await Promise.all(events.map(async event => ((await filterFn(event)) ? event : undefined))).then(
 332 |               events => events.filter((event): event is Awaited<DecodedEventWithTransaction<Abi, E>> => event != null),
 333 |             );
 334 |           }
 335 | 
 336 |           currentContinuation = tx.id; // update continuation in case of early break
 337 | 
 338 |           for (const event of events) {
 339 |             if (limit != null && result.length >= limit) {
 340 |               break outer;
 341 |             }
 342 |             result.push(event);
 343 |           }
 344 | 
 345 |           if (limit != null && result.length >= limit) {
 346 |             break outer;
 347 |           }
 348 |         }
 349 |       }
 350 | 
 351 |       currentContinuation = continuation;
 352 |       if (currentContinuation == null) {
 353 |         break;
 354 |       }
 355 |     }
 356 | 
 357 |     return { events: result, continuation: currentContinuation };
 358 |   }
 359 | 
 360 |   public async decodeTransaction(
 361 |     args: DecodeTransactionParams<Abi>,
 362 |   ): Promise<DecodedTransaction<Abi, AbiFunctionName<Abi>> | undefined> {
 363 |     await this._provider.ensureInitialized();
 364 |     try {
 365 |       const result = await this._provider.rawApi.decodeTransaction({
 366 |         transaction: serializeTransaction(args.transaction),
 367 |         abi: this._abi,
 368 |         method: args.methods,
 369 |       });
 370 |       if (result == null) {
 371 |         return undefined;
 372 |       }
 373 | 
 374 |       const { method, input, output } = result;
 375 | 
 376 |       const rawAbi = (this.methodsAbi as any)[method];
 377 | 
 378 |       return {
 379 |         method,
 380 |         input: rawAbi.inputs != null ? parseTokensObject(rawAbi.inputs, input) : {},
 381 |         output: rawAbi.outputs != null ? parseTokensObject(rawAbi.outputs, output) : {},
 382 |       } as DecodedTransaction<Abi, AbiFunctionName<Abi>>;
 383 |     } catch (_) {
 384 |       return undefined;
 385 |     }
 386 |   }
 387 | 
 388 |   public async decodeTransactionEvents(
 389 |     args: DecodeTransactionEventsParams,
 390 |   ): Promise<DecodedEvent<Abi, AbiEventName<Abi>>[]> {
 391 |     await this._provider.ensureInitialized();
 392 |     try {
 393 |       const { events } = await this._provider.rawApi.decodeTransactionEvents({
 394 |         transaction: serializeTransaction(args.transaction),
 395 |         abi: this._abi,
 396 |       });
 397 | 
 398 |       const result: DecodedEvent<Abi, AbiEventName<Abi>>[] = [];
 399 | 
 400 |       for (const { event, data } of events) {
 401 |         const rawAbi = (this.eventsAbi as any)[event];
 402 | 
 403 |         result.push({
 404 |           event,
 405 |           data: rawAbi.inputs != null ? parseTokensObject(rawAbi.inputs, data) : {},
 406 |         } as DecodedEvent<Abi, AbiEventName<Abi>>);
 407 |       }
 408 | 
 409 |       return result;
 410 |     } catch (_) {
 411 |       return [];
 412 |     }
 413 |   }
 414 | 
 415 |   public async decodeInputMessage(
 416 |     args: DecodeInputParams<Abi>,
 417 |   ): Promise<DecodedInput<Abi, AbiFunctionName<Abi>> | undefined> {
 418 |     await this._provider.ensureInitialized();
 419 |     try {
 420 |       const result = await this._provider.rawApi.decodeInput({
 421 |         abi: this._abi,
 422 |         body: args.body,
 423 |         internal: args.internal,
 424 |         method: args.methods,
 425 |       });
 426 |       if (result == null) {
 427 |         return undefined;
 428 |       }
 429 | 
 430 |       const { method, input } = result;
 431 | 
 432 |       const rawAbi = (this.methodsAbi as any)[method];
 433 | 
 434 |       return {
 435 |         method,
 436 |         input: rawAbi.inputs != null ? parseTokensObject(rawAbi.inputs, input) : {},
 437 |       } as DecodedInput<Abi, AbiFunctionName<Abi>>;
 438 |     } catch (_) {
 439 |       return undefined;
 440 |     }
 441 |   }
 442 | 
 443 |   public async decodeOutputMessage(
 444 |     args: DecodeOutputParams<Abi>,
 445 |   ): Promise<DecodedOutput<Abi, AbiFunctionName<Abi>> | undefined> {
 446 |     await this._provider.ensureInitialized();
 447 |     try {
 448 |       const result = await this._provider.rawApi.decodeOutput({
 449 |         abi: this._abi,
 450 |         body: args.body,
 451 |         method: args.methods,
 452 |       });
 453 |       if (result == null) {
 454 |         return undefined;
 455 |       }
 456 | 
 457 |       const { method, output } = result;
 458 | 
 459 |       const rawAbi = (this.methodsAbi as any)[method];
 460 | 
 461 |       return {
 462 |         method,
 463 |         output: rawAbi.outputs != null ? parseTokensObject(rawAbi.outputs, output) : {},
 464 |       } as DecodedOutput<Abi, AbiFunctionName<Abi>>;
 465 |     } catch (_) {
 466 |       return undefined;
 467 |     }
 468 |   }
 469 | 
 470 |   public async decodeEvent(args: DecodeEventParams<Abi>): Promise<DecodedEvent<Abi, AbiEventName<Abi>> | undefined> {
 471 |     await this._provider.ensureInitialized();
 472 |     try {
 473 |       const result = await this._provider.rawApi.decodeEvent({
 474 |         abi: this.abi,
 475 |         body: args.body,
 476 |         event: args.events,
 477 |       });
 478 |       if (result == null) {
 479 |         return undefined;
 480 |       }
 481 | 
 482 |       const { event, data } = result;
 483 | 
 484 |       const rawAbi = (this.eventsAbi as any)[event];
 485 | 
 486 |       return {
 487 |         event,
 488 |         data: rawAbi.inputs != null ? parseTokensObject(rawAbi.inputs, data) : {},
 489 |       } as DecodedEvent<Abi, AbiEventName<Abi>>;
 490 |     } catch (_) {
 491 |       return undefined;
 492 |     }
 493 |   }
 494 | }
 495 | 
 496 | /**
 497 |  * @category Contract
 498 |  */
 499 | export class TvmException extends Error {
 500 |   constructor(public readonly code: number) {
 501 |     super(`TvmException: ${code}`);
 502 |   }
 503 | }
 504 | 
 505 | /**
 506 |  * @category Contract
 507 |  */
 508 | export type DelayedMessageExecution = {
 509 |   /**
 510 |    * External message hash
 511 |    */
 512 |   messageHash: string;
 513 |   /**
 514 |    * Message expiration timestamp
 515 |    */
 516 |   expireAt: number;
 517 |   /**
 518 |    * Transaction promise (it will be rejected if the message has expired)
 519 |    */
 520 |   transaction: Promise<Transaction>;
 521 | };
 522 | 
 523 | /**
 524 |  * @category Contract
 525 |  */
 526 | export type ContractMethods<C> = {
 527 |   [K in AbiFunctionName<C>]: (
 528 |     params: AbiFunctionInputsWithDefault<C, K>,
 529 |   ) => ContractMethod<AbiFunctionInputs<C, K>, DecodedAbiFunctionOutputs<C, K>>;
 530 | };
 531 | 
 532 | /**
 533 |  * @category Contract
 534 |  */
 535 | export type ContractGetters<C> = {
 536 |   [K in AbiGetterName<C>]: (
 537 |     params: AbiGetterInputsWithDefault<C, K>,
 538 |   ) => ContractGetter<AbiGetterInputs<C, K>, DecodedAbiGetterOutputs<C, K>>;
 539 | };
 540 | 
 541 | /**
 542 |  * @category Contract
 543 |  */
 544 | export type ContractFields<C> = {
 545 |   [K in AbiFieldName<C>]: (params?: GetContractFieldsParams) => Promise<DecodedAbiFields<C>[K]>;
 546 | };
 547 | 
 548 | /**
 549 |  * @category Contract
 550 |  */
 551 | export interface ContractMethod<I, O> {
 552 |   /**
 553 |    * Target contract address
 554 |    */
 555 |   readonly address: Address;
 556 |   readonly abi: string;
 557 |   readonly method: string;
 558 |   readonly params: I;
 559 | 
 560 |   /**
 561 |    * Sends internal message and returns wallet transaction
 562 |    *
 563 |    * @param args
 564 |    */
 565 |   send(args: SendInternalParams): Promise<Transaction>;
 566 | 
 567 |   /**
 568 |    * Sends internal message without waiting for the transaction
 569 |    *
 570 |    * @param args
 571 |    */
 572 |   sendDelayed(args: SendInternalParams): Promise<DelayedMessageExecution>;
 573 | 
 574 |   /**
 575 |    * Sends internal message and waits for the new transaction on target address
 576 |    *
 577 |    * @param args
 578 |    */
 579 |   sendWithResult(
 580 |     args: SendInternalParams,
 581 |   ): Promise<{ parentTransaction: Transaction; childTransaction: Transaction; output?: O }>;
 582 | 
 583 |   /**
 584 |    * Estimates wallet fee for calling this method as an internal message
 585 |    *
 586 |    * @param args
 587 |    */
 588 |   estimateFees(args: SendInternalParams): Promise<string>;
 589 | 
 590 |   /**
 591 |    * Sends external message and returns contract transaction with parsed output
 592 |    *
 593 |    * @param args
 594 |    */
 595 |   sendExternal(args: SendExternalParams): Promise<{ transaction: Transaction; output?: O }>;
 596 | 
 597 |   /**
 598 |    * Sends external message without waiting for the transaction
 599 |    *
 600 |    * @param args
 601 |    */
 602 |   sendExternalDelayed(args: SendExternalDelayedParams): Promise<DelayedMessageExecution>;
 603 | 
 604 |   /**
 605 |    * Executes only a compute phase locally
 606 |    *
 607 |    * @param args
 608 |    */
 609 |   call(args?: CallParams): Promise<O>;
 610 | 
 611 |   /**
 612 |    * Encodes this method as an external message and
 613 |    * executes all transaction phases locally, producing a new state
 614 |    */
 615 |   executeExternal(args: ExecuteExternalParams): Promise<ExecutorOutput<O>>;
 616 | 
 617 |   /**
 618 |    * Encodes this method as an internal message and
 619 |    * executes all transaction phases locally, producing a new state
 620 |    */
 621 |   executeInternal(args: ExecuteInternalParams): Promise<ExecutorOutput<O>>;
 622 | 
 623 |   /**
 624 |    * Encodes method call as BOC
 625 |    */
 626 |   encodeInternal(): Promise<string>;
 627 | }
 628 | 
 629 | class ContractMethodImpl implements ContractMethod<any, any> {
 630 |   readonly params: RawTokensObject;
 631 | 
 632 |   constructor(
 633 |     readonly provider: ProviderRpcClient,
 634 |     readonly functionAbi: { inputs: AbiParam[]; outputs: AbiParam[] },
 635 |     readonly abi: string,
 636 |     readonly address: Address,
 637 |     readonly method: string,
 638 |     params: TokensObject,
 639 |   ) {
 640 |     this.params = serializeTokensObject(params);
 641 |   }
 642 | 
 643 |   async send(args: SendInternalParams): Promise<Transaction> {
 644 |     await this.provider.ensureInitialized();
 645 |     const { transaction } = await this.provider.rawApi.sendMessage({
 646 |       sender: args.from.toString(),
 647 |       recipient: this.address.toString(),
 648 |       amount: args.amount,
 649 |       bounce: args.bounce == null ? true : args.bounce,
 650 |       payload: {
 651 |         abi: this.abi,
 652 |         method: this.method,
 653 |         params: this.params,
 654 |       },
 655 |       stateInit: args.stateInit,
 656 |       ignoredActionPhaseCodes: args.ignoredActionPhaseCodes?.map(serializeIgnoreCode),
 657 |       ignoredComputePhaseCodes: args.ignoredComputePhaseCodes?.map(serializeIgnoreCode),
 658 |     });
 659 |     return parseTransaction(transaction);
 660 |   }
 661 | 
 662 |   async sendDelayed(args: SendInternalParams): Promise<DelayedMessageExecution> {
 663 |     await this.provider.ensureInitialized();
 664 | 
 665 |     const transactions = new DelayedTransactions();
 666 | 
 667 |     const subscription = await this.provider.subscribe('messageStatusUpdated');
 668 |     subscription.on('data', data => {
 669 |       if (!data.address.equals(args.from)) {
 670 |         return;
 671 |       }
 672 |       transactions.fillTransaction(data.hash, data.transaction);
 673 |     });
 674 | 
 675 |     const { message } = await this.provider.rawApi
 676 |       .sendMessageDelayed({
 677 |         sender: args.from.toString(),
 678 |         recipient: this.address.toString(),
 679 |         amount: args.amount,
 680 |         bounce: args.bounce == null ? true : args.bounce,
 681 |         payload: {
 682 |           abi: this.abi,
 683 |           method: this.method,
 684 |           params: this.params,
 685 |         },
 686 |         stateInit: args.stateInit,
 687 |         ignoredActionPhaseCodes: args.ignoredActionPhaseCodes?.map(serializeIgnoreCode),
 688 |         ignoredComputePhaseCodes: args.ignoredComputePhaseCodes?.map(serializeIgnoreCode),
 689 |       })
 690 |       .catch(e => {
 691 |         subscription.unsubscribe().catch(console.error);
 692 |         throw e;
 693 |       });
 694 | 
 695 |     const transaction = transactions
 696 |       .waitTransaction(this.address, message.hash)
 697 |       .finally(() => subscription.unsubscribe().catch(console.error));
 698 | 
 699 |     return {
 700 |       messageHash: message.hash,
 701 |       expireAt: message.expireAt,
 702 |       transaction,
 703 |     };
 704 |   }
 705 | 
 706 |   async sendWithResult(
 707 |     args: SendInternalWithResultParams,
 708 |   ): Promise<{ parentTransaction: Transaction; childTransaction: Transaction; output?: any }> {
 709 |     await this.provider.ensureInitialized();
 710 |     let subscriber = args.subscriber;
 711 |     const hasTempSubscriber = subscriber == null;
 712 |     if (subscriber == null) {
 713 |       subscriber = new this.provider.Subscriber();
 714 |     }
 715 | 
 716 |     try {
 717 |       // Parent transaction from wallet
 718 |       let parentTransaction: { transaction: Transaction; possibleMessages: Message[] } | undefined = undefined;
 719 | 
 720 |       // Child transaction promise
 721 |       let resolveChildTransactionPromise: ((transaction: Transaction) => void) | undefined;
 722 |       const childTransactionPromise = new Promise<Transaction>(resolve => {
 723 |         resolveChildTransactionPromise = tx => resolve(tx);
 724 |       });
 725 | 
 726 |       // Array for collecting transactions on target before parent transaction promise resolution
 727 |       const possibleChildren: Transaction[] = [];
 728 | 
 729 |       // Subscribe to this account
 730 |       subscriber
 731 |         .transactions(this.address)
 732 |         .flatMap(batch => batch.transactions)
 733 |         // Listen only messages from sender
 734 |         .filter(item => item.inMessage.src?.equals(args.from) || false)
 735 |         .on(tx => {
 736 |           if (parentTransaction == null) {
 737 |             // If we don't known whether the message was sent just collect all transactions from the sender
 738 |             possibleChildren.push(tx);
 739 |           } else if (parentTransaction.possibleMessages.findIndex(msg => msg.hash == tx.inMessage.hash) >= 0) {
 740 |             // Resolve promise if transaction was found
 741 |             resolveChildTransactionPromise?.(tx);
 742 |           }
 743 |         });
 744 | 
 745 |       // Send message
 746 |       const transaction = await this.send(args);
 747 |       // Extract all outgoing messages from the parent transaction to this contract
 748 |       const possibleMessages = transaction.outMessages.filter(msg => msg.dst?.equals(this.address) || false);
 749 | 
 750 |       // Update stream state
 751 |       parentTransaction = {
 752 |         transaction,
 753 |         possibleMessages,
 754 |       };
 755 | 
 756 |       // Check whether child transaction was already found
 757 |       const alreadyReceived = possibleChildren.find(tx => {
 758 |         return possibleMessages.findIndex(msg => msg.hash == tx.inMessage.hash) >= 0;
 759 |       });
 760 |       if (alreadyReceived != null) {
 761 |         resolveChildTransactionPromise?.(alreadyReceived);
 762 |       }
 763 | 
 764 |       const childTransaction = await childTransactionPromise;
 765 | 
 766 |       // Parse output
 767 |       let output: any = undefined;
 768 |       try {
 769 |         const result = await this.provider.rawApi.decodeTransaction({
 770 |           transaction: serializeTransaction(childTransaction),
 771 |           abi: this.abi,
 772 |           method: this.method,
 773 |         });
 774 |         if (result != null) {
 775 |           output = this.functionAbi.outputs != null ? parseTokensObject(this.functionAbi.outputs, result.output) : {};
 776 |         }
 777 |       } catch (e) {
 778 |         console.error(e);
 779 |       }
 780 | 
 781 |       // Done
 782 |       return {
 783 |         parentTransaction: parentTransaction.transaction,
 784 |         childTransaction,
 785 |         output,
 786 |       };
 787 |     } finally {
 788 |       hasTempSubscriber && (await subscriber.unsubscribe());
 789 |     }
 790 |   }
 791 | 
 792 |   async estimateFees(args: SendInternalParams): Promise<string> {
 793 |     await this.provider.ensureInitialized();
 794 |     const { fees } = await this.provider.rawApi.estimateFees({
 795 |       sender: args.from.toString(),
 796 |       recipient: this.address.toString(),
 797 |       amount: args.amount,
 798 |       payload: {
 799 |         abi: this.abi,
 800 |         method: this.method,
 801 |         params: this.params,
 802 |       },
 803 |       stateInit: args.stateInit,
 804 |     });
 805 |     return fees;
 806 |   }
 807 | 
 808 |   async sendExternal(args: SendExternalParams): Promise<{ transaction: Transaction; output?: any }> {
 809 |     await this.provider.ensureInitialized();
 810 |     const method =
 811 |       args.withoutSignature === true
 812 |         ? this.provider.rawApi.sendUnsignedExternalMessage
 813 |         : this.provider.rawApi.sendExternalMessage;
 814 | 
 815 |     const { transaction, output } = await method({
 816 |       publicKey: (args as any).publicKey,
 817 |       recipient: this.address.toString(),
 818 |       stateInit: args.stateInit,
 819 |       payload: {
 820 |         abi: this.abi,
 821 |         method: this.method,
 822 |         params: this.params,
 823 |       },
 824 |       local: args.local,
 825 |       executorParams: args.executorParams
 826 |         ? {
 827 |           disableSignatureCheck: args.executorParams.disableSignatureCheck,
 828 |           overrideBalance: args.executorParams.overrideBalance,
 829 |         }
 830 |         : undefined,
 831 |     });
 832 | 
 833 |     return {
 834 |       transaction: parseTransaction(transaction),
 835 |       output: output != null ? parseTokensObject(this.functionAbi.outputs, output) : undefined,
 836 |     };
 837 |   }
 838 | 
 839 |   async sendExternalDelayed(args: SendExternalDelayedParams): Promise<DelayedMessageExecution> {
 840 |     await this.provider.ensureInitialized();
 841 | 
 842 |     const transactions = new DelayedTransactions();
 843 | 
 844 |     const subscription = await this.provider.subscribe('messageStatusUpdated');
 845 |     subscription.on('data', data => {
 846 |       if (!data.address.equals(this.address)) {
 847 |         return;
 848 |       }
 849 |       transactions.fillTransaction(data.hash, data.transaction);
 850 |     });
 851 | 
 852 |     const { message } = await this.provider.rawApi
 853 |       .sendExternalMessageDelayed({
 854 |         publicKey: args.publicKey,
 855 |         recipient: this.address.toString(),
 856 |         stateInit: args.stateInit,
 857 |         payload: {
 858 |           abi: this.abi,
 859 |           method: this.method,
 860 |           params: this.params,
 861 |         },
 862 |       })
 863 |       .catch(e => {
 864 |         subscription.unsubscribe().catch(console.error);
 865 |         throw e;
 866 |       });
 867 | 
 868 |     const transaction = transactions
 869 |       .waitTransaction(this.address, message.hash)
 870 |       .finally(() => subscription.unsubscribe().catch(console.error));
 871 | 
 872 |     return {
 873 |       messageHash: message.hash,
 874 |       expireAt: message.expireAt,
 875 |       transaction,
 876 |     };
 877 |   }
 878 | 
 879 |   async call(args: CallParams = {}): Promise<any> {
 880 |     await this.provider.ensureInitialized();
 881 |     const { output, code } = await this.provider.rawApi.runLocal({
 882 |       address: this.address.toString(),
 883 |       cachedState: args.cachedState,
 884 |       responsible: args.responsible,
 885 |       functionCall: {
 886 |         abi: this.abi,
 887 |         method: this.method,
 888 |         params: this.params,
 889 |       },
 890 |       withSignatureId: args.withSignatureId,
 891 |       libraries: args.libraries,
 892 |     });
 893 | 
 894 |     if (output == null || code != 0) {
 895 |       throw new TvmException(code);
 896 |     } else {
 897 |       return parseTokensObject(this.functionAbi.outputs, output);
 898 |     }
 899 |   }
 900 | 
 901 |   /**
 902 |    * Encodes this method as an external message and
 903 |    * executes all transaction phases locally, producing a new state
 904 |    */
 905 |   async executeExternal(args: ExecuteExternalParams): Promise<ExecutorOutput<any>> {
 906 |     await this.provider.ensureInitialized();
 907 |     const { transaction, newState, output } = await this.provider.rawApi.executeLocal({
 908 |       address: this.address.toString(),
 909 |       cachedState: args.cachedState,
 910 |       stateInit: args.stateInit,
 911 |       payload: {
 912 |         abi: this.abi,
 913 |         method: this.method,
 914 |         params: this.params,
 915 |       },
 916 |       messageHeader: {
 917 |         type: 'external',
 918 |         publicKey: args.publicKey,
 919 |         withoutSignature: args.withoutSignature,
 920 |       },
 921 |       executorParams:
 922 |         args.executorParams != null
 923 |           ? {
 924 |             disableSignatureCheck: args.executorParams.disableSignatureCheck,
 925 |             overrideBalance: args.executorParams.overrideBalance,
 926 |           }
 927 |           : undefined,
 928 |     });
 929 | 
 930 |     return {
 931 |       transaction: parseTransaction(transaction),
 932 |       newState,
 933 |       output: output !== undefined ? parseTokensObject(this.functionAbi.outputs, output) : undefined,
 934 |     } as ExecutorOutput<any>;
 935 |   }
 936 | 
 937 |   /**
 938 |    * Encodes this method as an internal message and
 939 |    * executes all transaction phases locally, producing a new state
 940 |    */
 941 |   async executeInternal(args: ExecuteInternalParams): Promise<ExecutorOutput<any>> {
 942 |     await this.provider.ensureInitialized();
 943 |     const { transaction, newState, output } = await this.provider.rawApi.executeLocal({
 944 |       address: this.address.toString(),
 945 |       cachedState: args.cachedState,
 946 |       stateInit: args.stateInit,
 947 |       payload: {
 948 |         abi: this.abi,
 949 |         method: this.method,
 950 |         params: this.params,
 951 |       },
 952 |       messageHeader: {
 953 |         type: 'internal',
 954 |         sender: args.sender.toString(),
 955 |         amount: args.amount,
 956 |         bounce: args.bounce != null ? args.bounce : false,
 957 |         bounced: args.bounced,
 958 |       },
 959 |       executorParams:
 960 |         args.executorParams != null
 961 |           ? {
 962 |             disableSignatureCheck: args.executorParams.disableSignatureCheck,
 963 |             overrideBalance: args.executorParams.overrideBalance,
 964 |           }
 965 |           : undefined,
 966 |     });
 967 | 
 968 |     return {
 969 |       transaction: parseTransaction(transaction),
 970 |       newState,
 971 |       output: output !== undefined ? parseTokensObject(this.functionAbi.outputs, output) : undefined,
 972 |     } as ExecutorOutput<any>;
 973 |   }
 974 | 
 975 |   async encodeInternal(): Promise<string> {
 976 |     await this.provider.ensureInitialized();
 977 |     const { boc } = await this.provider.rawApi.encodeInternalInput({
 978 |       abi: this.abi,
 979 |       method: this.method,
 980 |       params: this.params,
 981 |     });
 982 |     return boc;
 983 |   }
 984 | }
 985 | 
 986 | /**
 987 |  * @category Contract
 988 |  */
 989 | export interface ContractGetter<I, O> {
 990 |   /**
 991 |    * Target contract address
 992 |    */
 993 |   readonly address: Address;
 994 |   readonly abi: string;
 995 |   readonly getter: string;
 996 |   readonly params: I;
 997 | 
 998 |   /**
 999 |    * Runs getter and returns parsed output
1000 |    *
1001 |    * @param args
1002 |    */
1003 |   run(args?: RunGetterParams): Promise<O>;
1004 | }
1005 | 
1006 | class ContractGetterImpl implements ContractGetter<any, any> {
1007 |   readonly params: RawTokensObject;
1008 | 
1009 |   constructor(
1010 |     readonly provider: ProviderRpcClient,
1011 |     readonly getterAbi: { inputs: AbiParam[]; outputs: AbiParam[] },
1012 |     readonly abi: string,
1013 |     readonly address: Address,
1014 |     readonly getter: string,
1015 |     params: TokensObject,
1016 |   ) {
1017 |     this.params = serializeTokensObject(params);
1018 |   }
1019 | 
1020 |   async run(args: RunGetterParams = {}): Promise<any> {
1021 |     await this.provider.ensureInitialized();
1022 |     const { output, code } = await this.provider.rawApi.runGetter({
1023 |       address: this.address.toString(),
1024 |       cachedState: args.cachedState,
1025 |       getterCall: {
1026 |         abi: this.abi,
1027 |         getter: this.getter,
1028 |         params: this.params,
1029 |       },
1030 |       withSignatureId: args.withSignatureId,
1031 |       libraries: args.libraries,
1032 |     });
1033 | 
1034 |     if (output == null || code != 0) {
1035 |       throw new TvmException(code);
1036 |     } else {
1037 |       return parseTokensObject(this.getterAbi.outputs, output);
1038 |     }
1039 |   }
1040 | }
1041 | 
1042 | /**
1043 |  * @category Contract
1044 |  */
1045 | export type GetContractFieldsParams = {
1046 |   /**
1047 |    * Cached contract state
1048 |    */
1049 |   cachedState?: FullContractState;
1050 |   /**
1051 |    * Don't fail if something is left in a cell after unpacking
1052 |    */
1053 |   allowPartial?: boolean;
1054 | };
1055 | 
1056 | /**
1057 |  * @category Contract
1058 |  */
1059 | export type SendInternalParams = {
1060 |   /**
1061 |    * Preferred wallet address.
1062 |    * It is the same address as the `accountInteraction.address`, but it must be explicitly provided
1063 |    */
1064 |   from: Address;
1065 |   /**
1066 |    * Amount of nano EVER to send
1067 |    */
1068 |   amount: string;
1069 |   /**
1070 |    * @default true
1071 |    */
1072 |   bounce?: boolean;
1073 |   /**
1074 |    * Optional base64 encoded TVC
1075 |    *
1076 |    * NOTE: If the selected contract do not support stateInit in the internal message,
1077 |    * an error is returned
1078 |    */
1079 |   stateInit?: string;
1080 |   /**
1081 |    * Optional compute phase error codes to be ignored during transaction tree simulation
1082 |    */
1083 |   ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError[];
1084 |   /**
1085 |    * Optional action phase error codes to be ignored during transaction tree simulation
1086 |    */
1087 |   ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError[];
1088 | };
1089 | 
1090 | /**
1091 |  * @category Contract
1092 |  */
1093 | export type SendInternalWithResultParams = SendInternalParams & {
1094 |   /**
1095 |    * Existing subscriber
1096 |    */
1097 |   subscriber?: Subscriber;
1098 | };
1099 | 
1100 | /**
1101 |  * @category Contract
1102 |  */
1103 | export type SendExternalParams = ({
1104 |   /**
1105 |    * Whether to prepare this message without signature. Default: false
1106 |    */
1107 |   withoutSignature: true;
1108 | } | {
1109 |   /**
1110 |    * The public key of the preferred account.
1111 |    * It is the same publicKey as the `accountInteraction.publicKey`, but it must be explicitly provided
1112 |    */
1113 |   publicKey: string;
1114 |   /**
1115 |    * Whether to prepare this message without signature. Default: false
1116 |    */
1117 |   withoutSignature?: false;
1118 | }) & {
1119 |   /**
1120 |    * Optional base64 encoded TVC
1121 |    */
1122 |   stateInit?: string;
1123 |   /**
1124 |    * Whether to run this message locally. Default: false
1125 |    */
1126 |   local?: boolean;
1127 |   /**
1128 |    * Optional executor parameters used during local contract execution
1129 |    */
1130 |   executorParams?: {
1131 |     /**
1132 |      * If `true`, signature verification always succeds
1133 |      */
1134 |     disableSignatureCheck?: boolean;
1135 |     /**
1136 |      * Explicit account balance in nano EVER
1137 |      */
1138 |     overrideBalance?: string | number;
1139 |   };
1140 | };
1141 | 
1142 | /**
1143 |  * @category Contract
1144 |  */
1145 | export type SendExternalDelayedParams = {
1146 |   /**
1147 |    * The public key of the preferred account.
1148 |    * It is the same publicKey as the `accountInteraction.publicKey`, but it must be explicitly provided
1149 |    */
1150 |   publicKey: string;
1151 |   /**
1152 |    * Optional base64 encoded TVC
1153 |    */
1154 |   stateInit?: string;
1155 | };
1156 | 
1157 | /**
1158 |  * @category Contract
1159 |  */
1160 | export type CallParams = {
1161 |   /**
1162 |    * Cached contract state
1163 |    */
1164 |   cachedState?: FullContractState;
1165 |   /**
1166 |    * Whether to run the method locally as responsible.
1167 |    *
1168 |    * This will use internal message with unlimited account balance.
1169 |    */
1170 |   responsible?: boolean;
1171 |   /**
1172 |    * Whether to use the signature id during signature verification (true by default).
1173 |    * - If `true`, uses the signature id of the selected network (if the capability is enabled).
1174 |    * - If `false`, forces signature check to ignore any signature id.
1175 |    * - If `number`, uses the specified number as a signature id.
1176 |    */
1177 |   withSignatureId?: boolean | number;
1178 |   /**
1179 |    * Optional libraries map
1180 |    **/
1181 |   libraries?: { [K: string]: string };
1182 | };
1183 | 
1184 | /**
1185 |  * @category Contract
1186 |  */
1187 | export type RunGetterParams = {
1188 |   /**
1189 |    * Cached contract state
1190 |    */
1191 |   cachedState?: FullContractState;
1192 |   /**
1193 |    * Whether to use the signature id during signature verification (true by default).
1194 |    * - If `true`, uses the signature id of the selected network (if the capability is enabled).
1195 |    * - If `false`, forces signature check to ignore any signature id.
1196 |    * - If `number`, uses the specified number as a signature id.
1197 |    */
1198 |   withSignatureId?: boolean | number;
1199 |   /**
1200 |    * Optional libraries map
1201 |    **/
1202 |   libraries?: { [K: string]: string };
1203 | };
1204 | 
1205 | /**
1206 |  * @category Contract
1207 |  */
1208 | export type ExecuteExternalParams = {
1209 |   /**
1210 |    * Cached contract state
1211 |    */
1212 |   cachedState?: FullContractState;
1213 |   /**
1214 |    * The public key of the signer.
1215 |    */
1216 |   publicKey: string;
1217 |   /**
1218 |    * Optional base64 encoded TVC
1219 |    */
1220 |   stateInit?: string;
1221 |   /**
1222 |    * Optional executor parameters used during local contract execution
1223 |    */
1224 |   executorParams?: {
1225 |     /**
1226 |      * If `true`, signature verification always succeeds
1227 |      */
1228 |     disableSignatureCheck?: boolean;
1229 |     /**
1230 |      * Explicit account balance in nano EVER
1231 |      */
1232 |     overrideBalance?: string | number;
1233 |   };
1234 |   /**
1235 |    * Whether to prepare this message without signature. Default: false
1236 |    */
1237 |   withoutSignature?: boolean;
1238 | };
1239 | 
1240 | /**
1241 |  * @category Contract
1242 |  */
1243 | export type ExecuteInternalParams = {
1244 |   /**
1245 |    * Cached contract state
1246 |    */
1247 |   cachedState?: FullContractState;
1248 |   /**
1249 |    * Optional base64 encoded TVC
1250 |    */
1251 |   stateInit?: string;
1252 |   /**
1253 |    * Message source address
1254 |    */
1255 |   sender: Address;
1256 |   /**
1257 |    * Amount of nano EVER to attach to the message
1258 |    */
1259 |   amount: string;
1260 |   /**
1261 |    * Whether to bounce message back on error. Default: false
1262 |    */
1263 |   bounce?: boolean;
1264 |   /**
1265 |    * Whether the constructed message is bounced. Default: false
1266 |    */
1267 |   bounced?: boolean;
1268 |   /**
1269 |    * Optional executor parameters used during local contract execution
1270 |    */
1271 |   executorParams?: {
1272 |     /**
1273 |      * If `true`, signature verification always succeeds
1274 |      */
1275 |     disableSignatureCheck?: boolean;
1276 |     /**
1277 |      * Explicit account balance in nano EVER
1278 |      */
1279 |     overrideBalance?: string | number;
1280 |   };
1281 | };
1282 | 
1283 | /**
1284 |  * @category Contract
1285 |  */
1286 | export type GetPastEventParams<Abi, E extends AbiEventName<Abi>> = {
1287 |   filter?: E | EventsFilter<Abi, AbiEventName<Abi>>;
1288 |   range?: EventsRange;
1289 |   limit?: number;
1290 |   continuation?: TransactionId;
1291 | };
1292 | 
1293 | /**
1294 |  * @category Contract
1295 |  */
1296 | export type WaitForEventParams<Abi, E extends AbiEventName<Abi>> = {
1297 |   filter?: E | EventsFilter<Abi, E>;
1298 |   range?: EventsRange;
1299 |   subscriber?: Subscriber;
1300 | };
1301 | 
1302 | /**
1303 |  * @category Contract
1304 |  */
1305 | export type EventsBatch<Abi, E extends AbiEventName<Abi>> = {
1306 |   events: DecodedEventWithTransaction<Abi, E>[];
1307 |   continuation?: TransactionId;
1308 | };
1309 | 
1310 | /**
1311 |  * @category Contract
1312 |  */
1313 | export type EventsFilter<Abi, E extends AbiEventName<Abi> = AbiEventName<Abi>> = (
1314 |   event: DecodedEventWithTransaction<Abi, E>,
1315 | ) => Promise<boolean> | boolean;
1316 | 
1317 | /**
1318 |  * @category Contract
1319 |  */
1320 | export type DecodedEventWithTransaction<Abi, E extends AbiEventName<Abi>> = DecodedEvent<Abi, E> & {
1321 |   transaction: Transaction;
1322 | };
1323 | 
1324 | /**
1325 |  * @category Contract
1326 |  */
1327 | export type EventsRange = {
1328 |   fromLt?: string;
1329 |   fromUtime?: number;
1330 |   toLt?: string;
1331 |   toUtime?: number;
1332 | };
1333 | 
1334 | /**
1335 |  * @category Contract
1336 |  */
1337 | export type DecodeTransactionParams<Abi> = {
1338 |   transaction: Transaction;
1339 |   methods: UniqueArray<AbiFunctionName<Abi>[]>;
1340 | };
1341 | 
1342 | /**
1343 |  * @category Contract
1344 |  */
1345 | export type DecodedTransaction<Abi, T> = T extends AbiFunctionName<Abi>
1346 |   ? { method: T; input: DecodedAbiFunctionInputs<Abi, T>; output: DecodedAbiFunctionOutputs<Abi, T> }
1347 |   : never;
1348 | 
1349 | /**
1350 |  * @category Contract
1351 |  */
1352 | export type DecodeInputParams<Abi> = {
1353 |   body: string;
1354 |   methods: UniqueArray<AbiFunctionName<Abi>[]>;
1355 |   internal: boolean;
1356 | };
1357 | 
1358 | /**
1359 |  * @category Contract
1360 |  */
1361 | export type DecodedInput<Abi, T> = T extends AbiFunctionName<Abi>
1362 |   ? { method: T; input: DecodedAbiFunctionInputs<Abi, T> }
1363 |   : never;
1364 | 
1365 | /**
1366 |  * @category Contract
1367 |  */
1368 | export type DecodeOutputParams<Abi> = {
1369 |   /**
1370 |    * Base64 encoded message body BOC
1371 |    */
1372 |   body: string;
1373 |   methods: UniqueArray<AbiFunctionName<Abi>[]>;
1374 | };
1375 | 
1376 | /**
1377 |  * @category Contract
1378 |  */
1379 | export type DecodeEventParams<Abi> = {
1380 |   /**
1381 |    * Base64 encoded message body BOC
1382 |    */
1383 |   body: string;
1384 |   events: UniqueArray<AbiEventName<Abi>[]>;
1385 | };
1386 | 
1387 | /**
1388 |  * @category Contract
1389 |  */
1390 | export type DecodedOutput<Abi, T> = T extends AbiFunctionName<Abi>
1391 |   ? { method: T; output: DecodedAbiFunctionOutputs<Abi, T> }
1392 |   : never;
1393 | 
1394 | /**
1395 |  * @category Contract
1396 |  */
1397 | export type DecodeTransactionEventsParams = {
1398 |   transaction: Transaction;
1399 | };
1400 | 
1401 | /**
1402 |  * @category Contract
1403 |  */
1404 | export type DecodedEvent<Abi, T> = T extends AbiEventName<Abi>
1405 |   ? { event: T; data: DecodedAbiEventData<Abi, T> }
1406 |   : never;
1407 | 
1408 | /**
1409 |  * @category Contract
1410 |  */
1411 | export type ExecutorOutput<O> = {
1412 |   /**
1413 |    * Executed transaction
1414 |    */
1415 |   transaction: Transaction;
1416 |   /**
1417 |    * Contract state after the executed transaction
1418 |    */
1419 |   newState: FullContractState | undefined;
1420 |   /**
1421 |    * Parsed function call output
1422 |    */
1423 |   output: O | undefined;
1424 | };
1425 | 


--------------------------------------------------------------------------------