@opcat-labs/opcat 1.0.0 → 1.0.2

package/test/data/bitcoind/script_tests.json

@@ -1435,7 +1435,7 @@
     "'a' 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "CAT",
     "P2SH,STRICTENC,MONOLITH_OPCODES",
-    "PUSH_SIZE",
+    "OK",
     "CAT oversized result"
   ],
 
@@ -1563,8 +1563,8 @@
     "-42 521",
     "NUM2BIN",
     "P2SH,STRICTENC,MONOLITH_OPCODES",
-    "PUSH_SIZE",
-    "Pushing 521 bytes is not"
+    "OK",
+    "Pushing 521 bytes is OK"
   ],
   ["-42 -3", "NUM2BIN", "P2SH,STRICTENC,MONOLITH_OPCODES", "PUSH_SIZE", "Negative size"],
   [
@@ -2670,14 +2670,14 @@
     "NOP",
     "'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'",
     "P2SH,STRICTENC",
-    "PUSH_SIZE",
+    "OK",
     ">520 byte push"
   ],
   [
     "0",
     "IF 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' ENDIF 1",
     "P2SH,STRICTENC",
-    "PUSH_SIZE",
+    "OK",
     ">520 byte push in non-executed IF branch"
   ],
   [

package/test/{hashCache.js → hashCache.cjs}

@@ -1,5 +1,6 @@
 'use strict';
-var HashCache = require('../lib/hash-cache');
+var opcat = require('../');
+var HashCache = opcat.HashCache;
 var chai = require('chai');
 var should = chai.should();
 

package/test/{hdkeys.js → hdkeys.cjs}

@@ -6,11 +6,11 @@
 //   * store test vectors at the end, latedef: false
 //   * should call is never defined
 
-var _ = require('../lib/util/_');
 require('chai').should();
 var expect = require('chai').expect;
 var sinon = require('sinon');
 var opcat = require('..');
+var _ = opcat.util._;
 var Networks = opcat.Networks;
 var HDPrivateKey = opcat.HDPrivateKey;
 var HDPublicKey = opcat.HDPublicKey;
@@ -57,7 +57,9 @@ describe('BIP32 compliance', function () {
   });
 
   it('can initialize a public key from an extended private key', function () {
-    new HDPublicKey(vector1MPrivate).xpubkey.should.equal(vector1MPublic);
+    expect(()=> {
+      new HDPublicKey(vector1MPrivate)
+    }).to.throw(/Argument is an extended private key/)
   });
 
   it('toString should be equal to the `xpubkey` member', function () {

package/test/{hdprivatekey.js → hdprivatekey.cjs}

@@ -1,15 +1,16 @@
 'use strict';
 
-var _ = require('../lib/util/_');
 var assert = require('assert');
 var should = require('chai').should();
 var expect = require('chai').expect;
 var opcat = require('..');
+var _ = opcat.util._;
 var errors = opcat.errors;
 var hdErrors = errors.HDPrivateKey;
 var buffer = require('buffer');
 var Networks = opcat.Networks;
-var JSUtil = require('../lib/util/js');
+var JSUtil = opcat.util.js;
+var Derivation = opcat.util.derivation;
 var HDPrivateKey = opcat.HDPrivateKey;
 var Base58Check = opcat.encoding.Base58Check;
 
@@ -237,20 +238,20 @@ describe('HDPrivate key interface', function () {
     invalid.forEach(function (datum) {
       it('rejects illegal path ' + datum, function () {
         HDPrivateKey.isValidPath(datum).should.equal(false);
-        expect(HDPrivateKey._getDerivationIndexes(datum)).to.equal(null);
+        expect(Derivation.getDerivationIndexes(datum)).to.equal(null);
       });
     });
 
     it('generates deriving indexes correctly', function () {
       var indexes;
 
-      indexes = HDPrivateKey._getDerivationIndexes('m/-1/12');
+      indexes = Derivation.getDerivationIndexes('m/-1/12');
       expect(indexes).to.equal(null);
 
-      indexes = HDPrivateKey._getDerivationIndexes("m/0/12/12'");
+      indexes = Derivation.getDerivationIndexes("m/0/12/12'");
       indexes.should.eql([0, 12, HDPrivateKey.Hardened + 12]);
 
-      indexes = HDPrivateKey._getDerivationIndexes("m/0/12/12'");
+      indexes = Derivation.getDerivationIndexes("m/0/12/12'");
       indexes.should.eql([0, 12, HDPrivateKey.Hardened + 12]);
     });
   });

package/test/{hdpublickey.js → hdpublickey.cjs}

@@ -7,7 +7,7 @@ var opcat = require('..');
 var buffer = require('buffer');
 var errors = opcat.errors;
 var hdErrors = opcat.errors.HDPublicKey;
-var JSUtil = require('../lib/util/js');
+var JSUtil = opcat.util.js;
 var HDPrivateKey = opcat.HDPrivateKey;
 var HDPublicKey = opcat.HDPublicKey;
 var Base58Check = opcat.encoding.Base58Check;
@@ -50,11 +50,6 @@ describe('HDPublicKey interface', function () {
       publicKey.should.equal(new HDPublicKey(publicKey));
     });
 
-    it('returns the correct xpubkey for a xprivkey', function () {
-      var publicKey = new HDPublicKey(xprivkey);
-      publicKey.xpubkey.should.equal(xpubkey);
-    });
-
     it('allows to call the argument with no "new" keyword', function () {
       HDPublicKey(xpubkey).xpubkey.should.equal(new HDPublicKey(xpubkey).xpubkey);
     });
@@ -64,7 +59,7 @@ describe('HDPublicKey interface', function () {
     });
 
     it('should not be able to change read-only properties', function () {
-      var publicKey = new HDPublicKey(xprivkey);
+      var publicKey = HDPublicKey(xpubkey);
       expect(function () {
         publicKey.fingerPrint = 'notafingerprint';
       }).to.throw(TypeError);

package/test/mnemonic/{pbkdf2.test.js → pbkdf2.test.cjs}

@@ -2,8 +2,8 @@
 
 var chai = require('chai');
 chai.should();
-
-var pbkdf2 = require('../../lib/mnemonic/pbkdf2');
+var opcat = require('../../')
+var pbkdf2 = opcat.Mnemonic.pbkdf2;
 
 describe('pbkdf2', function () {
   this.timeout(10000);

package/test/{networks.js → networks.cjs}

@@ -11,7 +11,7 @@ describe('Networks', function () {
   it('should contain all Networks', function () {
     should.exist(networks.livenet);
     should.exist(networks.testnet);
-    should.exist(networks.stn);
+    should.exist(networks.regtest);
     should.exist(networks.defaultNetwork);
   });
 
@@ -45,11 +45,6 @@ describe('Networks', function () {
     Buffer.isBuffer(testnet.networkMagic).should.equal(true);
   });
 
-  it('should have network magic for stn', function () {
-    var stn = networks.get('stn');
-    Buffer.isBuffer(stn.networkMagic).should.equal(true);
-  });
-
   it('can remove a custom network', function () {
     networks.remove(customnet);
     var net = networks.get('customnet');
@@ -80,10 +75,10 @@ describe('Networks', function () {
   var constants = ['name', 'alias', 'pubkeyhash', 'scripthash', 'xpubkey', 'xprivkey'];
 
   constants.forEach(function (key) {
-    it('should have constant ' + key + ' for livenet, testnet and stn', function () {
+    it('should have constant ' + key + ' for livenet, testnet and regtest', function () {
       networks.testnet.hasOwnProperty(key).should.equal(true);
       networks.livenet.hasOwnProperty(key).should.equal(true);
-      networks.stn.hasOwnProperty(key).should.equal(true);
+      networks.regtest.hasOwnProperty(key).should.equal(true);
     });
   });
 
@@ -106,44 +101,30 @@ describe('Networks', function () {
     expect(networks.get('testnet').name).to.equal('testnet');
   });
 
-  it('should have stn network', function () {
-    expect(networks.get('stn').name).to.equal('stn');
-  });
-
   it('should have livenet network', function () {
     expect(networks.get('livenet').name).to.equal('livenet');
   });
 
-  it('should have bchtest cashAddrPrefix', function () {
-    expect(networks.get('testnet').cashAddrPrefix).to.equal('bchtest');
+  it('should have opcattest cashAddrPrefix', function () {
+    expect(networks.get('testnet').cashAddrPrefix).to.equal('opcattest');
   });
 
-  it('should have bchreg cashAddrPrefix', function () {
-    expect(networks.get('regtest').cashAddrPrefix).to.equal('bchreg');
+  it('should have opcatreg cashAddrPrefix', function () {
+    expect(networks.get('regtest').cashAddrPrefix).to.equal('opcatreg');
   });
 
-  it('should have bchreg cashAddrPrefix after enableRegtest is called', function () {
+  it('should have opcatreg cashAddrPrefix after enableRegtest is called', function () {
     var network = networks.get('testnet');
     networks.enableRegtest();
-    expect(network.cashAddrPrefix).to.equal('bchreg');
+    expect(network.cashAddrPrefix).to.equal('opcatreg');
   });
 
-  it('should have bchtest cashAddrPrefix after disableRegtest is called', function () {
+  it('should have opcattest cashAddrPrefix after disableRegtest is called', function () {
     var network = networks.get('testnet');
     networks.disableRegtest();
-    expect(network.cashAddrPrefix).to.equal('bchtest');
-  });
-  it('should have opcatstn cashAddrPrefix after enableStn is called', function () {
-    var network = networks.get('testnet');
-    networks.enableStn();
-    expect(network.cashAddrPrefix).to.equal('opcatstn');
-  });
-
-  it('should have bchtest cashAddrPrefix after disableStn is called', function () {
-    var network = networks.get('testnet');
-    networks.disableStn();
-    expect(network.cashAddrPrefix).to.equal('bchtest');
+    expect(network.cashAddrPrefix).to.equal('opcattest');
   });
+ 
 
   it('converts to string using the "name" property', function () {
     networks.livenet.toString().should.equal('livenet');

package/test/{publickey.js → publickey.cjs}

@@ -46,7 +46,7 @@ describe('PublicKey', function () {
       var privhex = '906977a061af29276e40bf377042ffbde414e496ae2260bbf1fa9d085637bfff';
       var pubhex = '02a1633cafcc01ebfb6d78e39f687a1f0995c62fc95f51ead10a02ee0be551b5dc';
       var privkey = new PrivateKey(new BN(Buffer.from(privhex, 'hex')));
-      var pk = new PublicKey(privkey);
+      var pk = privkey.toPublicKey();
       pk.toString().should.equal(pubhex);
     });
 
@@ -512,7 +512,7 @@ describe('PublicKey', function () {
 
     it('should output known compressed pubkey with network for console', function () {
       var privkey = PrivateKey.fromWIF('L3T1s1TYP9oyhHpXgkyLoJFGniEgkv2Jhi138d7R2yJ9F4QdDU2m');
-      var pubkey = new PublicKey(privkey);
+      var pubkey = privkey.toPublicKey();
       pubkey
         .inspect()
         .should.equal(

package/test/script/{interpreter.js → interpreter.cjs}

@@ -2,18 +2,18 @@
 
 var should = require('chai').should();
 var opcat = require('../../');
-var Interpreter = opcat.Script.Interpreter;
+var Interpreter = opcat.Interpreter;
 var Transaction = opcat.Transaction;
 var PrivateKey = opcat.PrivateKey;
 var Script = opcat.Script;
 var BN = opcat.crypto.BN;
 var BufferWriter = opcat.encoding.BufferWriter;
 var Opcode = opcat.Opcode;
-var _ = require('../../lib/util/_');
+var _ = opcat.util._;
 
-var scriptTests = require('../data/bitcoind/script_tests');
-var txValid = require('../data/bitcoind/tx_valid');
-var txInvalid = require('../data/bitcoind/tx_invalid');
+var scriptTests = require('../data/bitcoind/script_tests.json');
+var txValid = require('../data/bitcoind/tx_valid.json');
+var txInvalid = require('../data/bitcoind/tx_invalid.json');
 
 // the script string format used in bitcoind data tests
 Script.fromBitcoindString = function (str) {

package/test/script/{script.js → script.cjs}

@@ -1349,7 +1349,10 @@ describe('Script', function () {
     });
 
     it('fails if content is not recognized', function () {
-      Script().toAddress(Networks.livenet).should.equal(false);
+      expect(function () {
+        Script().toAddress(Networks.livenet)
+      }).to.throw(/Can't derive address associated with script:/);
+
     });
 
     it('works for p2pkh output', function () {
@@ -1376,7 +1379,10 @@ describe('Script', function () {
     // no address scripts
     it('works for OP_RETURN script', function () {
       var script = new Script('OP_RETURN 20 0x99d29051af0c29adcb9040034752bba7dde33e35');
-      script.toAddress().should.equal(false);
+      expect(function () {
+        script.toAddress()
+      }).to.throw(/Can't derive address associated with script: OP_RETURN 20 0x99d29051af0c29adcb9040034752bba7dde33e35, needs to be p2pkh in, p2pkh out/);
+      
     });
   });
   describe('equals', function () {

package/test/transaction/{deserialize.js → deserialize.cjs}

@@ -1,6 +1,6 @@
 'use strict';
-
-var Transaction = require('../../lib/transaction');
+var opcat = require('../../')
+var Transaction = opcat.Transaction;
 
 var vectorsValid = require('../data/bitcoind/tx_valid.json');
 var vectorsInvalid = require('../data/bitcoind/tx_invalid.json');

package/test/transaction/input/{input.js → input.cjs}

@@ -13,7 +13,7 @@ var Input = opcat.Transaction.Input;
 describe('Transaction.Input', function () {
   var privateKey = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');
   var publicKey = privateKey.publicKey;
-  var address = new Address(publicKey, Networks.livenet);
+  var address = new Address(publicKey.toBuffer(), Networks.livenet);
   var output = {
     address: '33zbk2aSZYdNbRsMPPt6jgy6Kq1kQreqeb',
     prevTxId: '66e64ef8a3b384164b78453fa8c8194de9a473ba14f89485a0e433699daec140',

package/test/transaction/input/{multisig.js → multisig.cjs}

@@ -1,13 +1,14 @@
 'use strict';
 
 var should = require('chai').should();
-var _ = require('../../../lib/util/_');
 
 var opcat = require('../../..');
 var Transaction = opcat.Transaction;
 var PrivateKey = opcat.PrivateKey;
 var Script = opcat.Script;
 var MultiSigInput = opcat.Transaction.Input.MultiSig;
+var _ = opcat.util._;
+
 
 describe('MultiSigInput', function () {
   var privateKey1 = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');

package/test/transaction/input/{publickeyhash.js → publickeyhash.cjs}

@@ -12,7 +12,7 @@ var Networks = opcat.Networks;
 describe('PublicKeyHashInput', function () {
   var privateKey = new PrivateKey('KwF9LjRraetZuEjR8VqEq539z137LW5anYDUnVK11vM3mNMHTWb4');
   var publicKey = privateKey.publicKey;
-  var address = new Address(publicKey, Networks.livenet);
+  var address = new Address(publicKey.toBuffer(), Networks.livenet);
 
   var output = {
     address: address.toString(),

package/test/transaction/{sighash.js → sighash.cjs}

@@ -9,7 +9,7 @@ var Script = opcat.Script;
 var BN = opcat.crypto.BN;
 var Transaction = opcat.Transaction;
 var Signature = opcat.crypto.Signature;
-var sighash = Transaction.sighash;
+var sighash = Transaction.Sighash;
 
 var vectorsSighash = require('../data/sighash.json');
 

package/test/transaction/{transaction.js → transaction.cjs}

@@ -5,7 +5,7 @@ var expect = require('chai').expect;
 var sinon = require('sinon');
 
 var opcat = require('../..');
-var _ = opcat.deps._;
+var _ = opcat.util._
 var BN = opcat.crypto.BN;
 var Transaction = opcat.Transaction;
 var Input = opcat.Transaction.Input;
@@ -258,8 +258,8 @@ describe('Transaction', function () {
         .from(simpleUtxoWith100000Satoshis)
         .addSafeData('genesis is coming')
         .change(changeAddress)
+        .feePerKb(50)
         .sign(privateKey);
-      // update if change default FEE_PER_KB
       transaction
         .serialize()
         .should.equal(

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types",
+    "strict": false
+  },
+  "include": ["cjs/**/*.cjs"],
+  "exclude": ["node_modules/**/*"]
+}

package/types/address.d.cts

@@ -0,0 +1,252 @@
+export = Address;
+/**
+ * Instantiate an address from an address String or Buffer, a public key hash Buffer,
+ * or a {@link PublicKey} Buffer.
+ *
+ * This is an immutable class, and if the first parameter provided to this constructor is an
+ * `Address` instance, the same argument will be returned.
+ *
+ * An address has two key properties: `network` and `type`. The type is either
+ * `Address.PayToPublicKeyHash` (value is the `'pubkeyhash'` string).
+ * The network is an instance of {@link Network}.
+ * You can quickly check whether an address is of a given kind by using the methods
+ * `isPayToPublicKeyHash`
+ *
+ * @example
+ * ```javascript
+ * // validate that an input field is valid
+ * var error = Address.getValidationError(input, 'testnet');
+ * if (!error) {
+ *   var address = Address(input, 'testnet');
+ * } else {
+ *   // invalid network or checksum (typo?)
+ *   var message = error.messsage;
+ * }
+ *
+ * // get an address from a public key
+ * var address = Address(publicKey, 'testnet').toString();
+ * ```
+ *
+ * @param {*} data - The encoded data in various formats
+ * @param {Network|String|number} [network] - The network: 'livenet' or 'testnet'
+ * @param {string} [type] - The type of address: 'pubkey'
+ * @returns {Address} A new valid and frozen instance of an Address
+ * @constructor
+ */
+declare function Address(data: any, network?: Network | string | number, type?: string): Address;
+declare class Address {
+    /**
+     * Instantiate an address from an address String or Buffer, a public key hash Buffer,
+     * or a {@link PublicKey} Buffer.
+     *
+     * This is an immutable class, and if the first parameter provided to this constructor is an
+     * `Address` instance, the same argument will be returned.
+     *
+     * An address has two key properties: `network` and `type`. The type is either
+     * `Address.PayToPublicKeyHash` (value is the `'pubkeyhash'` string).
+     * The network is an instance of {@link Network}.
+     * You can quickly check whether an address is of a given kind by using the methods
+     * `isPayToPublicKeyHash`
+     *
+     * @example
+     * ```javascript
+     * // validate that an input field is valid
+     * var error = Address.getValidationError(input, 'testnet');
+     * if (!error) {
+     *   var address = Address(input, 'testnet');
+     * } else {
+     *   // invalid network or checksum (typo?)
+     *   var message = error.messsage;
+     * }
+     *
+     * // get an address from a public key
+     * var address = Address(publicKey, 'testnet').toString();
+     * ```
+     *
+     * @param {*} data - The encoded data in various formats
+     * @param {Network|String|number} [network] - The network: 'livenet' or 'testnet'
+     * @param {string} [type] - The type of address: 'pubkey'
+     * @returns {Address} A new valid and frozen instance of an Address
+     * @constructor
+     */
+    constructor(data: any, network?: Network | string | number, type?: string);
+    get hashBuffer(): any;
+    get network(): any;
+    get type(): any;
+    private _classifyArguments;
+    /**
+     * Returns true if an address is of pay to public key hash type
+     * @return boolean
+     */
+    isPayToPublicKeyHash(): boolean;
+    /**
+     * Will return a buffer representation of the address
+     *
+     * @returns {Buffer} Bitcoin address buffer
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the address to a hexadecimal string representation.
+     * @returns {string} The hexadecimal string representation of the address.
+     */
+    toHex(): string;
+    /**
+     * Converts the address to a publickey hash string representation.
+     * @returns {string} The hexadecimal string of the publickey hash buffer.
+     */
+    toPublickeyHash(): string;
+    /**
+     * @returns {Object} A plain object with the address information
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Will return a string formatted for the console
+     *
+     * @returns {string} Bitcoin address
+     */
+    inspect(): string;
+    /**
+     * Will return a the base58 string representation of the address
+     *
+     * @returns {string} Bitcoin address
+     */
+    toString(): string;
+}
+declare namespace Address {
+    let PayToPublicKeyHash: string;
+    /**
+     * @param {Buffer} hash - An instance of a hash Buffer
+     * @returns {Object} An object with keys: hashBuffer
+     * @private
+     */
+    function _transformHash(hash: Buffer): any;
+    /**
+     * Deserializes an address serialized through `Address#toObject()`
+     * @param {Object} data
+     * @param {string} data.hash - the hash that this address encodes
+     * @param {string} data.type - either 'pubkeyhash' or 'scripthash'
+     * @param {Network=} data.network - the name of the network associated
+     * @return {Address}
+     * @private
+     */
+    function _transformObject(data: {
+        hash: string;
+        type: string;
+        network?: Network;
+    }): Address;
+    /**
+     * Internal function to discover the network and type based on the first data byte
+     *
+     * @param {Buffer} buffer - An instance of a hex encoded address Buffer
+     * @returns {Object} An object with keys: network and type
+     * @private
+     */
+    function _classifyFromVersion(buffer: Buffer): any;
+    /**
+     * Internal function to transform a bitcoin address buffer
+     *
+     * @param {Buffer} buffer - An instance of a hex encoded address Buffer
+     * @param {string=} network - The network: 'livenet' or 'testnet'
+     * @param {string=} type - The type: 'pubkeyhash' or 'scripthash'
+     * @returns {Object} An object with keys: hashBuffer, network and type
+     * @private
+     */
+    function _transformBuffer(buffer: Buffer, network?: string, type?: string): any;
+    /**
+     * Internal function to transform a {@link PublicKey}
+     *
+     * @param {PublicKey} pubkey - An instance of PublicKey
+     * @returns {Object} An object with keys: hashBuffer, type
+     * @private
+     */
+    function _transformPublicKey(pubkey: PublicKey): any;
+    /**
+     * Internal function to transform a bitcoin cash address string
+     *
+     * @param {string} data
+     * @param {String|Network=} network - either a Network instance, 'livenet', or 'testnet'
+     * @param {string=} type - The type: 'pubkeyhash'
+     * @returns {Object} An object with keys: hashBuffer, network and type
+     * @private
+     */
+    function _transformString(data: string, network?: any, type?: string): any;
+    /**
+     * Instantiate an address from a PublicKey buffer
+     *
+     * @param {Buffer} data - A buffer of the public key
+     * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
+     * @returns {Address} A new valid and frozen instance of an Address
+     */
+    function fromPublicKey(data: Buffer, network: any): Address;
+    /**
+     * Instantiate an address from a ripemd160 public key hash
+     *
+     * @param {Buffer} hash - An instance of buffer of the hash
+     * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
+     * @returns {Address} A new valid and frozen instance of an Address
+     */
+    function fromPublicKeyHash(hash: Buffer, network: any): Address;
+    /**
+     * Instantiate an address from a bitcoin address buffer
+     *
+     * @param {Buffer} buffer - An instance of buffer of the address
+     * @param {String|Network=} network - either a Network instance, 'livenet', or 'testnet'
+     * @param {string=} type - The type of address: 'pubkey'
+     * @returns {Address} A new valid and frozen instance of an Address
+     */
+    function fromBuffer(buffer: Buffer, network?: any, type?: string): Address;
+    /**
+     * Creates an Address instance from a hex string.
+     * @param {string} hex - The hex string representation of the address.
+     * @param {Network} network - The network type (e.g., 'mainnet', 'testnet').
+     * @param {AddressType} [type] - Optional address type.
+     * @returns {Address} The Address instance created from the hex string.
+     */
+    function fromHex(hex: string, network: Network, type?: AddressType): Address;
+    /**
+     * Instantiate an address from an address string
+     *
+     * @param {string} str - An string of the bitcoin address
+     * @param {String|Network=} network - either a Network instance, 'livenet', or 'testnet'
+     * @param {string=} type - The type of address: 'pubkey'
+     * @returns {Address} A new valid and frozen instance of an Address
+     */
+    function fromString(str: string, network?: any, type?: string): Address;
+    /**
+     * Instantiate an address from an Object
+     *
+     * @param {string} json - An JSON string or Object with keys: hash, network and type
+     * @returns {Address} A new valid instance of an Address
+     */
+    function fromObject(obj: any): Address;
+    /**
+     * Will return a validation error if exists
+     *
+     * @example
+     * ```javascript
+     * // a network mismatch error
+     * var error = Address.getValidationError('15vkcKf7gB23wLAnZLmbVuMiiVDc1Nm4a2', 'testnet');
+     * ```
+     *
+     * @param {string} data - The encoded data
+     * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
+     * @param {string} type - The type of address: 'pubkey'
+     * @returns {null|Error} The corresponding error message
+     */
+    function getValidationError(data: string, network: any, type: string): Error;
+    /**
+     * Will return a boolean if an address is valid
+     *
+     * @example
+     * ```javascript
+     * assert(Address.isValid('15vkcKf7gB23wLAnZLmbVuMiiVDc1Nm4a2', 'livenet'));
+     * ```
+     *
+     * @param {string} data - The encoded data
+     * @param {String|Network} network - either a Network instance, 'livenet', or 'testnet'
+     * @param {string} type - The type of address: 'pubkey'
+     * @returns {boolean} The corresponding error message
+     */
+    function isValid(data: string, network: any, type: string): boolean;
+}